@juzi/wechaty 1.0.0

package/dist/esm/src/schemas/room-events.d.ts

@@ -0,0 +1,103 @@
+import type TypedEventEmitter from 'typed-emitter';
+import type { ContactInterface, MessageInterface, RoomInterface, RoomInvitationInterface } from '../user-modules/mod.js';
+export declare const ROOM_EVENT_DICT: {
+    invite: string;
+    join: string;
+    leave: string;
+    message: string;
+    topic: string;
+};
+export declare type RoomEventName = keyof typeof ROOM_EVENT_DICT;
+/**
+ * @desc       Room Class Event Type
+ * @typedef    RoomEventName
+ * @property   {string}  join  - Emit when anyone join any room.
+ * @property   {string}  topic - Get topic event, emitted when someone change room topic.
+ * @property   {string}  leave - Emit when anyone leave the room.<br>
+ *                               If someone leaves the room by themselves, WeChat will not notice other people in the room, so the bot will never get the "leave" event.
+ */
+/**
+ * @desc       Room Class Event Function
+ * @typedef    RoomEventFunction
+ * @property   {Function} room-join       - (this: Room, inviteeList: Contact[] , inviter: Contact)  => void
+ * @property   {Function} room-topic      - (this: Room, topic: string, oldTopic: string, changer: Contact) => void
+ * @property   {Function} room-leave      - (this: Room, leaver: Contact) => void
+ */
+/**
+ * @listens Room
+ * @param   {RoomEventName}      event      - Emit WechatyEvent
+ * @param   {RoomEventFunction}  listener   - Depends on the WechatyEvent
+ * @return  {this}                          - this for chain
+ *
+ * @example <caption>Event:join </caption>
+ * const bot = new Wechaty()
+ * await bot.start()
+ * // after logged in...
+ * const room = await bot.Room.find({topic: 'topic of your room'}) // change `event-room` to any room topic in your WeChat
+ * if (room) {
+ *   room.on('join', (room, inviteeList, inviter) => {
+ *     const nameList = inviteeList.map(c => c.name()).join(',')
+ *     console.log(`Room got new member ${nameList}, invited by ${inviter}`)
+ *   })
+ * }
+ *
+ * @example <caption>Event:leave </caption>
+ * const bot = new Wechaty()
+ * await bot.start()
+ * // after logged in...
+ * const room = await bot.Room.find({topic: 'topic of your room'}) // change `event-room` to any room topic in your WeChat
+ * if (room) {
+ *   room.on('leave', (room, leaverList) => {
+ *     const nameList = leaverList.map(c => c.name()).join(',')
+ *     console.log(`Room lost member ${nameList}`)
+ *   })
+ * }
+ *
+ * @example <caption>Event:message </caption>
+ * const bot = new Wechaty()
+ * await bot.start()
+ * // after logged in...
+ * const room = await bot.Room.find({topic: 'topic of your room'}) // change `event-room` to any room topic in your WeChat
+ * if (room) {
+ *   room.on('message', (message) => {
+ *     console.log(`Room received new message: ${message}`)
+ *   })
+ * }
+ *
+ * @example <caption>Event:topic </caption>
+ * const bot = new Wechaty()
+ * await bot.start()
+ * // after logged in...
+ * const room = await bot.Room.find({topic: 'topic of your room'}) // change `event-room` to any room topic in your WeChat
+ * if (room) {
+ *   room.on('topic', (room, topic, oldTopic, changer) => {
+ *     console.log(`Room topic changed from ${oldTopic} to ${topic} by ${changer.name()}`)
+ *   })
+ * }
+ *
+ * @example <caption>Event:invite </caption>
+ * const bot = new Wechaty()
+ * await bot.start()
+ * // after logged in...
+ * const room = await bot.Room.find({topic: 'topic of your room'}) // change `event-room` to any room topic in your WeChat
+ * if (room) {
+ *   room.on('invite', roomInvitation => roomInvitation.accept())
+ * }
+ *
+ */
+declare type RoomEventListenerInvite = (this: RoomInterface, inviter: ContactInterface, invitation: RoomInvitationInterface) => void | Promise<void>;
+declare type RoomEventListenerJoin = (this: RoomInterface, inviteeList: ContactInterface[], inviter: ContactInterface, date?: Date) => void | Promise<void>;
+declare type RoomEventListenerLeave = (this: RoomInterface, leaverList: ContactInterface[], remover?: ContactInterface, date?: Date) => void | Promise<void>;
+declare type RoomEventListenerMessage = (this: RoomInterface, message: MessageInterface, date?: Date) => void | Promise<void>;
+declare type RoomEventListenerTopic = (this: RoomInterface, topic: string, oldTopic: string, changer: ContactInterface, date?: Date) => void | Promise<void>;
+interface RoomEventListeners {
+    invite: RoomEventListenerInvite;
+    join: RoomEventListenerJoin;
+    leave: RoomEventListenerLeave;
+    message: RoomEventListenerMessage;
+    topic: RoomEventListenerTopic;
+}
+declare const RoomEventEmitter: new () => TypedEventEmitter<RoomEventListeners>;
+export type { RoomEventListeners, RoomEventListenerInvite, RoomEventListenerJoin, RoomEventListenerLeave, RoomEventListenerMessage, RoomEventListenerTopic, };
+export { RoomEventEmitter, };
+//# sourceMappingURL=room-events.d.ts.map

package/dist/esm/src/schemas/room-events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"room-events.d.ts","sourceRoot":"","sources":["../../../../src/schemas/room-events.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,iBAAiB,MAAO,eAAe,CAAA;AAEnD,OAAO,KAAK,EACV,gBAAgB,EAChB,gBAAgB,EAChB,aAAa,EACb,uBAAuB,EACxB,MAAwB,wBAAwB,CAAA;AAEjD,eAAO,MAAM,eAAe;;;;;;CAM3B,CAAA;AACD,oBAAY,aAAa,GAAG,MAAM,OAAO,eAAe,CAAA;AAExD;;;;;;;GAOG;AAEH;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AAEH,aAAK,uBAAuB,GAAI,CAAC,IAAI,EAAE,aAAa,EAAE,OAAO,EAAE,gBAAgB,EAAE,UAAU,EAAE,uBAAuB,KAAe,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;AACvJ,aAAK,qBAAqB,GAAM,CAAC,IAAI,EAAE,aAAa,EAAE,WAAW,EAAE,gBAAgB,EAAE,EAAE,OAAO,EAAE,gBAAgB,EAAG,IAAI,CAAC,EAAE,IAAI,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;AACvJ,aAAK,sBAAsB,GAAK,CAAC,IAAI,EAAE,aAAa,EAAE,UAAU,EAAE,gBAAgB,EAAE,EAAE,OAAO,CAAC,EAAE,gBAAgB,EAAE,IAAI,CAAC,EAAE,IAAI,KAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;AACvJ,aAAK,wBAAwB,GAAG,CAAC,IAAI,EAAE,aAAa,EAAE,OAAO,EAAE,gBAAgB,EAAE,IAAI,CAAC,EAAE,IAAI,KAAuC,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;AACvJ,aAAK,sBAAsB,GAAK,CAAC,IAAI,EAAE,aAAa,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,gBAAgB,EAAE,IAAI,CAAC,EAAE,IAAI,KAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;AAEvJ,UAAU,kBAAkB;IAC1B,MAAM,EAAI,uBAAuB,CAAA;IACjC,IAAI,EAAM,qBAAqB,CAAA;IAC/B,KAAK,EAAK,sBAAsB,CAAA;IAChC,OAAO,EAAG,wBAAwB,CAAA;IAClC,KAAK,EAAK,sBAAsB,CAAA;CACjC;AAED,QAAA,MAAM,gBAAgB,YAAoC,kBACxD,kBAAkB,CACnB,CAAA;AAED,YAAY,EACV,kBAAkB,EAClB,uBAAuB,EACvB,qBAAqB,EACrB,sBAAsB,EACtB,wBAAwB,EACxB,sBAAsB,GACvB,CAAA;AACD,OAAO,EACL,gBAAgB,GACjB,CAAA"}

package/dist/esm/src/schemas/room-events.js

@@ -0,0 +1,11 @@
+import { EventEmitter } from 'events';
+export const ROOM_EVENT_DICT = {
+    invite: 'tbw',
+    join: 'tbw',
+    leave: 'tbw',
+    message: 'message that received in this room',
+    topic: 'tbw',
+};
+const RoomEventEmitter = EventEmitter;
+export { RoomEventEmitter, };
+//# sourceMappingURL=room-events.js.map

package/dist/esm/src/schemas/room-events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"room-events.js","sourceRoot":"","sources":["../../../../src/schemas/room-events.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAQ,QAAQ,CAAA;AAUvC,MAAM,CAAC,MAAM,eAAe,GAAG;IAC7B,MAAM,EAAI,KAAK;IACf,IAAI,EAAM,KAAK;IACf,KAAK,EAAK,KAAK;IACf,OAAO,EAAG,oCAAoC;IAC9C,KAAK,EAAK,KAAK;CAChB,CAAA;AAiGD,MAAM,gBAAgB,GAAG,YAExB,CAAA;AAUD,OAAO,EACL,gBAAgB,GACjB,CAAA"}

package/dist/esm/src/schemas/wechaty-events.d.ts

@@ -0,0 +1,218 @@
+import type TypedEventEmitter from 'typed-emitter';
+import type { GError } from 'gerror';
+import * as PUPPET from 'wechaty-puppet';
+import type { FriendshipInterface, ContactSelfInterface, RoomInterface, RoomInvitationInterface, ContactInterface, MessageInterface, PostInterface } from '../user-modules/mod.js';
+declare const WECHATY_EVENT_DICT: {
+    readonly dong: "Should be emitted after we call `Wechaty.ding()`";
+    readonly error: "Will be emitted when there's an Error occurred.";
+    readonly heartbeat: "Will be emitted periodically after the Wechaty started. If not, means that the Wechaty had died.";
+    readonly puppet: "Will be emitted when the puppet has been set.";
+    readonly ready: "All underlined data source are ready for use.";
+    readonly start: "Will be emitted after the Wechaty had been started.";
+    readonly stop: "Will be emitted after the Wechaty had been stopped.";
+    readonly friendship: string;
+    readonly login: string;
+    readonly logout: string;
+    readonly message: string;
+    readonly post: string;
+    readonly 'room-invite': string;
+    readonly 'room-join': string;
+    readonly 'room-leave': string;
+    readonly 'room-topic': string;
+    readonly scan: string;
+};
+declare type WechatyEventName = keyof typeof WECHATY_EVENT_DICT;
+/**
+ * Wechaty Event Listener Interfaces
+ */
+declare type WechatyEventListenerDong = (data?: string) => void | Promise<void>;
+declare type WechatyEventListenerError = (error: GError) => void | Promise<void>;
+declare type WechatyEventListenerFriendship = (friendship: FriendshipInterface) => void | Promise<void>;
+declare type WechatyEventListenerHeartbeat = (data: any) => void | Promise<void>;
+declare type WechatyEventListenerLogin = (user: ContactSelfInterface) => void | Promise<void>;
+declare type WechatyEventListenerLogout = (user: ContactSelfInterface, reason?: string) => void | Promise<void>;
+declare type WechatyEventListenerMessage = (message: MessageInterface) => void | Promise<void>;
+declare type WechatyEventListenerPost = (post: PostInterface) => void | Promise<void>;
+declare type WechatyEventListenerPuppet = (puppet: PUPPET.impls.PuppetInterface) => void | Promise<void>;
+declare type WechatyEventListenerReady = () => void | Promise<void>;
+declare type WechatyEventListenerRoomInvite = (roomInvitation: RoomInvitationInterface) => void | Promise<void>;
+declare type WechatyEventListenerRoomJoin = (room: RoomInterface, inviteeList: ContactInterface[], inviter: ContactInterface, date?: Date) => void | Promise<void>;
+declare type WechatyEventListenerRoomLeave = (room: RoomInterface, leaverList: ContactInterface[], remover?: ContactInterface, date?: Date) => void | Promise<void>;
+declare type WechatyEventListenerRoomTopic = (room: RoomInterface, newTopic: string, oldTopic: string, changer: ContactInterface, date?: Date) => void | Promise<void>;
+declare type WechatyEventListenerScan = (qrcode: string, status: PUPPET.types.ScanStatus, data?: string) => void | Promise<void>;
+declare type WechatyEventListenerStartStop = () => void | Promise<void>;
+/**
+ * @desc       Wechaty Class Event Type
+ * @typedef    WechatyEventName
+ * @property   {string}  error       - When the bot get error, there will be a Wechaty error event fired.
+ * @property   {string}  login       - After the bot login full successful, the event login will be emitted, with a Contact of current logged in user.
+ * @property   {string}  logout      - Logout will be emitted when bot detected log out, with a Contact of the current login user.
+ * @property   {string}  heartbeat   - Get heartbeat of the bot.
+ * @property   {string}  friendship  - When someone sends you a friend request, there will be a Wechaty friendship event fired.
+ * @property   {string}  message     - Emit when there's a new message.
+ * @property   {string}  ready       - Emit when all data has load completed, in wechaty-puppet-padchat, it means it has sync Contact and Room completed
+ * @property   {string}  room-join   - Emit when anyone join any room.
+ * @property   {string}  room-topic  - Get topic event, emitted when someone change room topic.
+ * @property   {string}  room-leave  - Emit when anyone leave the room.<br>
+ *                                   - If someone leaves the room by themselves, WeChat will not notice other people in the room, so the bot will never get the "leave" event.
+ * @property   {string}  room-invite - Emit when there is a room invitation, see more in  {@link RoomInvitation}
+ * @property   {string}  scan        - A scan event will be emitted when the bot needs to show you a QR Code for scanning. </br>
+ *                                    It is recommend to install qrcode-terminal(run `npm install qrcode-terminal`) in order to show qrcode in the terminal.
+ */
+/**
+ * @desc       Wechaty Class Event Function
+ * @typedef    WechatyEventFunction
+ * @property   {Function} error           -(this: Wechaty, error: Error) => void | Promise<void> callback function
+ * @property   {Function} login           -(this: Wechaty, user: ContactSelf)=> void
+ * @property   {Function} logout          -(this: Wechaty, user: ContactSelf) => void | Promise<void>
+ * @property   {Function} scan            -(this: Wechaty, url: string, code: number) => void | Promise<void> <br>
+ * <ol>
+ * <li>URL: {String} the QR code image URL</li>
+ * <li>code: {Number} the scan status code. some known status of the code list here is:</li>
+ * </ol>
+ * <ul>
+ * <li>0 initial_</li>
+ * <li>200 login confirmed</li>
+ * <li>201 scanned, wait for confirm</li>
+ * <li>408 waits for scan</li>
+ * </ul>
+ * @property   {Function} heartbeat       -(this: Wechaty, data: any) => void | Promise<void>
+ * @property   {Function} friendship      -(this: Wechaty, friendship: Friendship) => void | Promise<void>
+ * @property   {Function} message         -(this: Wechaty, message: Message) => void | Promise<void>
+ * @property   {Function} ready           -(this: Wechaty) => void | Promise<void>
+ * @property   {Function} room-join       -(this: Wechaty, room: Room, inviteeList: Contact[],  inviter: Contact) => void | Promise<void>
+ * @property   {Function} room-topic      -(this: Wechaty, room: Room, newTopic: string, oldTopic: string, changer: Contact) => void | Promise<void>
+ * @property   {Function} room-leave      -(this: Wechaty, room: Room, leaverList: Contact[]) => void | Promise<void>
+ * @property   {Function} room-invite     -(this: Wechaty, room: Room, roomInvitation: RoomInvitation) => void | Promise<void> <br>
+ *                                        see more in  {@link RoomInvitation}
+ */
+/**
+ * @listens Wechaty
+ * @param   {WechatyEventName}      event      - Emit WechatyEvent
+ * @param   {WechatyEventFunction}  listener   - Depends on the WechatyEvent
+ *
+ * @return  {Wechaty}                          - this for chaining,
+ * see advanced {@link https://github.com/wechaty/getting-started/wiki/FAQ#36-why-wechatyonevent-listener-return-wechaty|chaining usage}
+ *
+ * @desc
+ * When the bot get message, it will emit the following Event.
+ *
+ * You can do anything you want when in these events functions.
+ * The main Event name as follows:
+ * - **scan**: Emit when the bot needs to show you a QR Code for scanning. After scan the qrcode, you can login
+ * - **login**: Emit when bot login full successful.
+ * - **logout**: Emit when bot detected log out.
+ * - **message**: Emit when there's a new message.
+ *
+ * see more in {@link WechatyEventName}
+ *
+ * @example <caption>Event:scan</caption>
+ * // Scan Event will emit when the bot needs to show you a QR Code for scanning
+ *
+ * bot.on('scan', (url, status) => {
+ *   console.log(`[${status}] Scan ${url} to login.` )
+ * })
+ *
+ * @example <caption>Event:login </caption>
+ * // Login Event will emit when bot login full successful.
+ *
+ * bot.on('login', (user) => {
+ *   console.log(`user ${user} login`)
+ * })
+ *
+ * @example <caption>Event:logout </caption>
+ * // Logout Event will emit when bot detected log out.
+ *
+ * bot.on('logout', (user) => {
+ *   console.log(`user ${user} logout`)
+ * })
+ *
+ * @example <caption>Event:message </caption>
+ * // Message Event will emit when there's a new message.
+ *
+ * wechaty.on('message', (message) => {
+ *   console.log(`message ${message} received`)
+ * })
+ *
+ * @example <caption>Event:friendship </caption>
+ * // Friendship Event will emit when got a new friend request, or friendship is confirmed.
+ *
+ * bot.on('friendship', (friendship) => {
+ *   if(friendship.type() === Friendship.Type.Receive){ // 1. receive new friendship request from new contact
+ *     const contact = friendship.contact()
+ *     let result = await friendship.accept()
+ *       if(result){
+ *         console.log(`Request from ${contact.name()} is accept successfully!`)
+ *       } else{
+ *         console.log(`Request from ${contact.name()} failed to accept!`)
+ *       }
+ *  } else if (friendship.type() === Friendship.Type.Confirm) { // 2. confirm friendship
+ *       console.log(`new friendship confirmed with ${contact.name()}`)
+ *    }
+ *  })
+ *
+ * @example <caption>Event:room-join </caption>
+ * // room-join Event will emit when someone join the room.
+ *
+ * bot.on('room-join', (room, inviteeList, inviter) => {
+ *   const nameList = inviteeList.map(c => c.name()).join(',')
+ *   console.log(`Room ${room.topic()} got new member ${nameList}, invited by ${inviter}`)
+ * })
+ *
+ * @example <caption>Event:room-leave </caption>
+ * // room-leave Event will emit when someone leave the room.
+ *
+ * bot.on('room-leave', (room, leaverList) => {
+ *   const nameList = leaverList.map(c => c.name()).join(',')
+ *   console.log(`Room ${room.topic()} lost member ${nameList}`)
+ * })
+ *
+ * @example <caption>Event:room-topic </caption>
+ * // room-topic Event will emit when someone change the room's topic.
+ *
+ * bot.on('room-topic', (room, topic, oldTopic, changer) => {
+ *   console.log(`Room ${room.topic()} topic changed from ${oldTopic} to ${topic} by ${changer.name()}`)
+ * })
+ *
+ * @example <caption>Event:room-invite, RoomInvitation has been encapsulated as a RoomInvitation Class. </caption>
+ * // room-invite Event will emit when there's an room invitation.
+ *
+ * bot.on('room-invite', async roomInvitation => {
+ *   try {
+ *     console.log(`received room-invite event.`)
+ *     await roomInvitation.accept()
+ *   } catch (e) {
+ *     console.error(e)
+ *   }
+ * })
+ *
+ * @example <caption>Event:error </caption>
+ * // error Event will emit when there's an error occurred.
+ *
+ * bot.on('error', (error) => {
+ *   console.error(error)
+ * })
+ */
+interface WechatyEventListeners {
+    'room-invite': WechatyEventListenerRoomInvite;
+    'room-join': WechatyEventListenerRoomJoin;
+    'room-leave': WechatyEventListenerRoomLeave;
+    'room-topic': WechatyEventListenerRoomTopic;
+    dong: WechatyEventListenerDong;
+    error: WechatyEventListenerError;
+    friendship: WechatyEventListenerFriendship;
+    heartbeat: WechatyEventListenerHeartbeat;
+    login: WechatyEventListenerLogin;
+    logout: WechatyEventListenerLogout;
+    message: WechatyEventListenerMessage;
+    post: WechatyEventListenerPost;
+    puppet: WechatyEventListenerPuppet;
+    ready: WechatyEventListenerReady;
+    scan: WechatyEventListenerScan;
+    start: WechatyEventListenerStartStop;
+    stop: WechatyEventListenerStartStop;
+}
+declare const WechatyEventEmitter: new () => TypedEventEmitter<WechatyEventListeners>;
+export type { WechatyEventName, WechatyEventListeners, WechatyEventListenerDong, WechatyEventListenerError, WechatyEventListenerFriendship, WechatyEventListenerHeartbeat, WechatyEventListenerLogin, WechatyEventListenerLogout, WechatyEventListenerMessage, WechatyEventListenerPost, WechatyEventListenerPuppet, WechatyEventListenerReady, WechatyEventListenerRoomInvite, WechatyEventListenerRoomJoin, WechatyEventListenerRoomLeave, WechatyEventListenerRoomTopic, WechatyEventListenerScan, WechatyEventListenerStartStop, };
+export { WechatyEventEmitter, };
+//# sourceMappingURL=wechaty-events.d.ts.map

package/dist/esm/src/schemas/wechaty-events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wechaty-events.d.ts","sourceRoot":"","sources":["../../../../src/schemas/wechaty-events.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,iBAAiB,MAAQ,eAAe,CAAA;AAEpD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAO,QAAQ,CAAA;AACrC,OAAO,KAAK,MAAM,MAAW,gBAAgB,CAAA;AAE7C,OAAO,KAAK,EACV,mBAAmB,EACnB,oBAAoB,EACpB,aAAa,EACb,uBAAuB,EACvB,gBAAgB,EAChB,gBAAgB,EAChB,aAAa,EACd,MAA4B,wBAAwB,CAAA;AAErD,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;CASd,CAAA;AAEV,aAAK,gBAAgB,GAAI,MAAM,OAAO,kBAAkB,CAAA;AAExD;;GAEG;AACH,aAAK,wBAAwB,GAAS,CAAC,IAAI,CAAC,EAAE,MAAM,KAAuF,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;AAC/J,aAAK,yBAAyB,GAAQ,CAAC,KAAK,EAAE,MAAM,KAAyE,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;AACjJ,aAAK,8BAA8B,GAAG,CAAC,UAAU,EAAE,mBAAmB,KAAqE,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;AAC/J,aAAK,6BAA6B,GAAI,CAAC,IAAI,EAAE,GAAG,KAA2F,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;AAC/J,aAAK,yBAAyB,GAAQ,CAAC,IAAI,EAAE,oBAAoB,KAA0E,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;AAC/J,aAAK,0BAA0B,GAAO,CAAC,IAAI,EAAE,oBAAoB,EAAE,MAAM,CAAC,EAAE,MAAM,KAAyD,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;AAC/J,aAAK,2BAA2B,GAAM,CAAC,OAAO,EAAE,gBAAgB,KAA2E,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;AAC/J,aAAK,wBAAwB,GAAS,CAAC,IAAI,EAAE,aAAa,KAA2E,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;AACzJ,aAAK,0BAA0B,GAAO,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,CAAC,eAAe,KAAiE,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;AAChK,aAAK,yBAAyB,GAAQ,MAAqG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;AAC/J,aAAK,8BAA8B,GAAG,CAAC,cAAc,EAAE,uBAAuB,KAA6D,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;AAC/J,aAAK,4BAA4B,GAAK,CAAC,IAAI,EAAE,aAAa,EAAE,WAAW,EAAE,gBAAgB,EAAE,EAAE,OAAO,EAAE,gBAAgB,EAAG,IAAI,CAAC,EAAE,IAAI,KAAO,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;AAC/J,aAAK,6BAA6B,GAAI,CAAC,IAAI,EAAE,aAAa,EAAE,UAAU,EAAE,gBAAgB,EAAE,EAAG,OAAO,CAAC,EAAE,gBAAgB,EAAE,IAAI,CAAC,EAAE,IAAI,KAAO,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;AAC/J,aAAK,6BAA6B,GAAI,CAAC,IAAI,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,gBAAgB,EAAE,IAAI,CAAC,EAAE,IAAI,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;AAC/J,aAAK,wBAAwB,GAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,KAAK,CAAC,UAAU,EAAE,IAAI,CAAC,EAAE,MAAM,KAAuC,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;AAChK,aAAK,6BAA6B,GAAI,MAAqG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;AAE/J;;;;;;;;;;;;;;;;;GAiBG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0GG;AACH,UAAU,qBAAqB;IAC7B,aAAa,EAAG,8BAA8B,CAAA;IAC9C,WAAW,EAAK,4BAA4B,CAAA;IAC5C,YAAY,EAAI,6BAA6B,CAAA;IAC7C,YAAY,EAAI,6BAA6B,CAAA;IAC7C,IAAI,EAAY,wBAAwB,CAAA;IACxC,KAAK,EAAW,yBAAyB,CAAA;IACzC,UAAU,EAAM,8BAA8B,CAAA;IAC9C,SAAS,EAAO,6BAA6B,CAAA;IAC7C,KAAK,EAAW,yBAAyB,CAAA;IACzC,MAAM,EAAU,0BAA0B,CAAA;IAC1C,OAAO,EAAS,2BAA2B,CAAA;IAC3C,IAAI,EAAY,wBAAwB,CAAA;IACxC,MAAM,EAAU,0BAA0B,CAAA;IAC1C,KAAK,EAAW,yBAAyB,CAAA;IACzC,IAAI,EAAY,wBAAwB,CAAA;IACxC,KAAK,EAAW,6BAA6B,CAAA;IAC7C,IAAI,EAAY,6BAA6B,CAAA;CAC9C;AAED,QAAA,MAAM,mBAAmB,YAAoC,kBAC3D,qBAAqB,CACtB,CAAA;AAED,YAAY,EACV,gBAAgB,EAChB,qBAAqB,EAErB,wBAAwB,EACxB,yBAAyB,EACzB,8BAA8B,EAC9B,6BAA6B,EAC7B,yBAAyB,EACzB,0BAA0B,EAC1B,2BAA2B,EAC3B,wBAAwB,EACxB,0BAA0B,EAC1B,yBAAyB,EACzB,8BAA8B,EAC9B,4BAA4B,EAC5B,6BAA6B,EAC7B,6BAA6B,EAC7B,wBAAwB,EACxB,6BAA6B,GAC9B,CAAA;AACD,OAAO,EACL,mBAAmB,GACpB,CAAA"}

package/dist/esm/src/schemas/wechaty-events.js

@@ -0,0 +1,15 @@
+import { EventEmitter } from 'events';
+import * as PUPPET from 'wechaty-puppet';
+const WECHATY_EVENT_DICT = {
+    ...PUPPET.types.CHAT_EVENT_DICT,
+    dong: 'Should be emitted after we call `Wechaty.ding()`',
+    error: "Will be emitted when there's an Error occurred.",
+    heartbeat: 'Will be emitted periodically after the Wechaty started. If not, means that the Wechaty had died.',
+    puppet: 'Will be emitted when the puppet has been set.',
+    ready: 'All underlined data source are ready for use.',
+    start: 'Will be emitted after the Wechaty had been started.',
+    stop: 'Will be emitted after the Wechaty had been stopped.',
+};
+const WechatyEventEmitter = EventEmitter;
+export { WechatyEventEmitter, };
+//# sourceMappingURL=wechaty-events.js.map

package/dist/esm/src/schemas/wechaty-events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wechaty-events.js","sourceRoot":"","sources":["../../../../src/schemas/wechaty-events.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAc,QAAQ,CAAA;AAI7C,OAAO,KAAK,MAAM,MAAW,gBAAgB,CAAA;AAY7C,MAAM,kBAAkB,GAAG;IACzB,GAAG,MAAM,CAAC,KAAK,CAAC,eAAe;IAC/B,IAAI,EAAQ,kDAAkD;IAC9D,KAAK,EAAO,iDAAiD;IAC7D,SAAS,EAAG,kGAAkG;IAC9G,MAAM,EAAM,+CAA+C;IAC3D,KAAK,EAAO,+CAA+C;IAC3D,KAAK,EAAO,qDAAqD;IACjE,IAAI,EAAQ,qDAAqD;CACzD,CAAA;AAsMV,MAAM,mBAAmB,GAAG,YAE3B,CAAA;AAuBD,OAAO,EACL,mBAAmB,GACpB,CAAA"}

package/dist/esm/src/schemas/wechaty-options.d.ts

@@ -0,0 +1,20 @@
+import type * as PUPPET from 'wechaty-puppet';
+import type { MemoryCard } from 'memory-card';
+import type { OfficialPuppetNpmName } from '../puppet-config.js';
+interface OptionsPuppetInstance {
+    puppet?: PUPPET.impls.PuppetInterface;
+}
+interface OptionsPuppetName {
+    puppet?: OfficialPuppetNpmName;
+    puppetOptions?: PUPPET.PuppetOptions;
+}
+interface WechatyOptionsBase {
+    memory?: MemoryCard;
+    name?: string;
+    ioToken?: string;
+}
+declare type WechatyOptionsPuppetInstance = WechatyOptionsBase & OptionsPuppetInstance;
+declare type WechatyOptionsPuppetName = WechatyOptionsBase & OptionsPuppetName;
+declare type WechatyOptions = WechatyOptionsPuppetInstance | WechatyOptionsPuppetName;
+export { type WechatyOptions, type WechatyOptionsPuppetName, };
+//# sourceMappingURL=wechaty-options.d.ts.map

package/dist/esm/src/schemas/wechaty-options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wechaty-options.d.ts","sourceRoot":"","sources":["../../../../src/schemas/wechaty-options.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,MAAM,gBAAgB,CAAA;AAC7C,OAAO,KAAK,EACV,UAAU,EACX,MAA4B,aAAa,CAAA;AAE1C,OAAO,KAAK,EACV,qBAAqB,EACtB,MAAkC,qBAAqB,CAAA;AAExD,UAAU,qBAAqB;IAC7B,MAAM,CAAC,EAAE,MAAM,CAAC,KAAK,CAAC,eAAe,CAAC;CACvC;AAED,UAAU,iBAAiB;IACzB,MAAM,CAAC,EAAU,qBAAqB,CAAA;IACtC,aAAa,CAAC,EAAG,MAAM,CAAC,aAAa,CAAA;CACtC;AAED,UAAU,kBAAkB;IAC1B,MAAM,CAAC,EAAU,UAAU,CAAC;IAC5B,IAAI,CAAC,EAAY,MAAM,CAAC;IACxB,OAAO,CAAC,EAAS,MAAM,CAAC;CACzB;AAED,aAAK,4BAA4B,GAC7B,kBAAkB,GAClB,qBAAqB,CAAA;AAEzB,aAAK,wBAAwB,GACzB,kBAAkB,GAClB,iBAAiB,CAAA;AAErB,aAAK,cAAc,GACf,4BAA4B,GAC5B,wBAAwB,CAAA;AAE5B,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,wBAAwB,GAC9B,CAAA"}

package/dist/esm/src/schemas/wechaty-options.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=wechaty-options.js.map

package/dist/esm/src/schemas/wechaty-options.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wechaty-options.js","sourceRoot":"","sources":["../../../../src/schemas/wechaty-options.ts"],"names":[],"mappings":""}

package/dist/esm/src/user-mixins/mod.d.ts

@@ -0,0 +1,7 @@
+import { poolifyMixin } from './poolify.js';
+import type { PoolifyMixin } from './poolify.js';
+import { validationMixin } from './validation.js';
+import { wechatifyMixin, wechatifyMixinBase } from './wechatify.js';
+export type { PoolifyMixin, };
+export { poolifyMixin, validationMixin, wechatifyMixin, wechatifyMixinBase, };
+//# sourceMappingURL=mod.d.ts.map

package/dist/esm/src/user-mixins/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../../src/user-mixins/mod.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACb,MAAwB,cAAc,CAAA;AACvC,OAAO,KAAK,EACV,YAAY,EACb,MAAwB,cAAc,CAAA;AACvC,OAAO,EACL,eAAe,EAChB,MAAwB,iBAAiB,CAAA;AAC1C,OAAO,EACL,cAAc,EACd,kBAAkB,EACnB,MAAwB,gBAAgB,CAAA;AAEzC,YAAY,EACV,YAAY,GACb,CAAA;AACD,OAAO,EACL,YAAY,EACZ,eAAe,EACf,cAAc,EACd,kBAAkB,GACnB,CAAA"}

package/dist/esm/src/user-mixins/mod.js

@@ -0,0 +1,5 @@
+import { poolifyMixin, } from './poolify.js';
+import { validationMixin, } from './validation.js';
+import { wechatifyMixin, wechatifyMixinBase, } from './wechatify.js';
+export { poolifyMixin, validationMixin, wechatifyMixin, wechatifyMixinBase, };
+//# sourceMappingURL=mod.js.map

package/dist/esm/src/user-mixins/mod.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.js","sourceRoot":"","sources":["../../../../src/user-mixins/mod.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,GACb,MAAwB,cAAc,CAAA;AAIvC,OAAO,EACL,eAAe,GAChB,MAAwB,iBAAiB,CAAA;AAC1C,OAAO,EACL,cAAc,EACd,kBAAkB,GACnB,MAAwB,gBAAgB,CAAA;AAKzC,OAAO,EACL,YAAY,EACZ,eAAe,EACf,cAAc,EACd,kBAAkB,GACnB,CAAA"}

package/dist/esm/src/user-mixins/poolify.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Class mixins are a pattern for sharing code between classes using standard JavaScript.
+ * https://lit.dev/docs/composition/mixins/
+ */
+import type { Constructor } from 'clone-class';
+interface PoolifyMixin<T> {
+    new (...args: any[]): T;
+    pool: Map<string, T>;
+}
+/**
+ * https://stackoverflow.com/a/60378737/1123955
+ *
+ * You want something like partial type parameter inference,
+ * which is not currently a feature of TypeScript (see microsoft/TypeScript#26242).
+ * Right now you either have to specify all type parameters manually
+ * or let the compiler infer all type parameters;
+ * there's no partial inference.
+ * As you've noticed,
+ * generic type parameter defaults do not scratch this itch;
+ * a default turns off inference.
+ */
+declare const poolifyMixin: <MixinBase extends Constructor<{}, {}>>(mixinBase: MixinBase) => <T>() => ((abstract new (...args: any[]) => {}) & {
+    _pool?: Map<string, T> | undefined;
+    readonly pool: Map<string, T>;
+    load<L extends import("clone-class/dist/esm/src/constructor").ClassInterface<{}> & {
+        new (...args: any[]): T;
+        prototype: T;
+    } & PoolifyMixin<T>>(this: L, id: string): T;
+}) & MixinBase;
+export type { PoolifyMixin, };
+export { poolifyMixin, };
+//# sourceMappingURL=poolify.d.ts.map

package/dist/esm/src/user-mixins/poolify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"poolify.d.ts","sourceRoot":"","sources":["../../../../src/user-mixins/poolify.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AAG9C,UAAU,YAAY,CAAC,CAAC;IACtB,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,CAAC,CAAA;IACvB,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,CAAC,CAAC,CAAA;CACrB;AAED;;;;;;;;;;;GAWG;AACH,QAAA,MAAM,YAAY,qGAiCQ,GAAG,EAAE;;;;;;sCAblB,MAAM;cAoBlB,CAAA;AAED,YAAY,EACV,YAAY,GACb,CAAA;AACD,OAAO,EACL,YAAY,GACb,CAAA"}

package/dist/esm/src/user-mixins/poolify.js

@@ -0,0 +1,44 @@
+import { log } from 'wechaty-puppet';
+/**
+ * https://stackoverflow.com/a/60378737/1123955
+ *
+ * You want something like partial type parameter inference,
+ * which is not currently a feature of TypeScript (see microsoft/TypeScript#26242).
+ * Right now you either have to specify all type parameters manually
+ * or let the compiler infer all type parameters;
+ * there's no partial inference.
+ * As you've noticed,
+ * generic type parameter defaults do not scratch this itch;
+ * a default turns off inference.
+ */
+const poolifyMixin = (mixinBase) => () => {
+    log.verbose('PoolifyMixin', 'poolifyMixin(%s)', mixinBase.name);
+    class AbstractPoolifyMixin extends mixinBase {
+        static _pool;
+        static get pool() {
+            /**
+             * hasOwnProperty() is important because we are calling this from the child classes
+             */
+            if (!Object.prototype.hasOwnProperty.call(this, '_pool')) {
+                log.verbose('PoolifyMixin', 'get pool() init pool');
+                this._pool = new Map();
+            }
+            return this._pool; // FIXME: why we need "!" at here?
+        }
+        static load(id) {
+            const existingItem = this.pool.get(id);
+            if (existingItem) {
+                return existingItem;
+            }
+            const newItem = new this(id);
+            this.pool.set(id, newItem);
+            return newItem;
+        }
+        constructor(...args) {
+            super(...args);
+        }
+    }
+    return AbstractPoolifyMixin;
+};
+export { poolifyMixin, };
+//# sourceMappingURL=poolify.js.map

package/dist/esm/src/user-mixins/poolify.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"poolify.js","sourceRoot":"","sources":["../../../../src/user-mixins/poolify.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAA;AAOpC;;;;;;;;;;;GAWG;AACH,MAAM,YAAY,GAAG,CAAgC,SAAoB,EAAE,EAAE,CAAC,GAAM,EAAE;IACpF,GAAG,CAAC,OAAO,CAAC,cAAc,EAAE,kBAAkB,EAAE,SAAS,CAAC,IAAI,CAAC,CAAA;IAE/D,MAAe,oBAAqB,SAAQ,SAAS;QAEnD,MAAM,CAAC,KAAK,CAAsB;QAClC,MAAM,KAAK,IAAI;YACb;;eAEG;YACH,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,EAAE,OAAO,CAAC,EAAE;gBACxD,GAAG,CAAC,OAAO,CAAC,cAAc,EAAE,sBAAsB,CAAC,CAAA;gBACnD,IAAI,CAAC,KAAK,GAAG,IAAI,GAAG,EAAa,CAAA;aAClC;YAED,OAAO,IAAI,CAAC,KAAM,CAAA,CAAE,kCAAkC;QACxD,CAAC;QAEM,MAAM,CAAC,IAAI,CAEhB,EAAa;YAEb,MAAM,YAAY,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAA;YACtC,IAAI,YAAY,EAAE;gBAChB,OAAO,YAAY,CAAA;aACpB;YAED,MAAM,OAAO,GAAG,IAAI,IAAI,CAAC,EAAE,CAAC,CAAA;YAC5B,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,OAAO,CAAC,CAAA;YAE1B,OAAO,OAAO,CAAA;QAChB,CAAC;QAED,YAAa,GAAG,IAAW;YACzB,KAAK,CAAC,GAAG,IAAI,CAAC,CAAA;QAChB,CAAC;KAEF;IAED,OAAO,oBAAoB,CAAA;AAC7B,CAAC,CAAA;AAKD,OAAO,EACL,YAAY,GACb,CAAA"}

package/dist/esm/src/user-mixins/poolify.spec.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env -S node --no-warnings --loader ts-node/esm
+export {};
+//# sourceMappingURL=poolify.spec.d.ts.map

package/dist/esm/src/user-mixins/poolify.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"poolify.spec.d.ts","sourceRoot":"","sources":["../../../../src/user-mixins/poolify.spec.ts"],"names":[],"mappings":""}

package/dist/esm/src/user-mixins/poolify.spec.js

@@ -0,0 +1,51 @@
+#!/usr/bin/env -S node --no-warnings --loader ts-node/esm
+import { test, } from 'tstest';
+import { poolifyMixin, } from './poolify.js';
+import { wechatifyUserModule, wechatifyMixin, } from './wechatify.js';
+test('poolifyMixin()', async (t) => {
+    class Life {
+        meaning = 42;
+        constructor() { }
+    }
+    class UserClassTest extends poolifyMixin(Life)() {
+        id = 0;
+        constructor() { super(); }
+    }
+    const meaningType = true;
+    t.ok(meaningType, 'should get meaning type for class instance');
+    const poolGetType = true;
+    t.ok(poolGetType, 'should get Life type for pool.get()');
+    const loadType = true;
+    t.ok(loadType, 'should get UserClassTest type for load()');
+});
+test('poolifyMixin() pool', async (t) => {
+    class Life {
+        meaning = 42;
+    }
+    class UserClassTest extends wechatifyMixin(poolifyMixin(Life)()) {
+        id = 0;
+        constructor() { super(); }
+    }
+    const UserClass1 = wechatifyUserModule(UserClassTest)({});
+    const UserClass2 = wechatifyUserModule(UserClassTest)({});
+    t.equal(UserClass1.pool.size, 0, 'should be size 0 for class 1');
+    t.equal(UserClass2.pool.size, 0, 'should be size 0 for class 2');
+    UserClass1.load('id1');
+    t.equal(UserClass1.pool.size, 1, 'should be size 1 for class 1 after class1.load()');
+    t.equal(UserClass2.pool.size, 0, 'should be size 0 for class 2 after class1.load()');
+    UserClass2.load('id2');
+    t.equal(UserClass1.pool.size, 1, 'should be size 1 for class 1 after class2.load()');
+    t.equal(UserClass2.pool.size, 1, 'should be size 1 for class 2 after class2.load()');
+});
+test('static findAll()', async (t) => {
+    class UserClassTest extends wechatifyMixin(poolifyMixin(Object)()) {
+        static async findAll(id) {
+            return this.load(id);
+        }
+        id = 0;
+        constructor() { super(); }
+    }
+    const typeTest = true;
+    t.ok(typeTest, 'should return the UserClassTest type');
+});
+//# sourceMappingURL=poolify.spec.js.map

package/dist/esm/src/user-mixins/poolify.spec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"poolify.spec.js","sourceRoot":"","sources":["../../../../src/user-mixins/poolify.spec.ts"],"names":[],"mappings":";AACA,OAAO,EACL,IAAI,GAEL,MAAoB,QAAQ,CAAA;AAE7B,OAAO,EACL,YAAY,GACb,MAA4B,cAAc,CAAA;AAC3C,OAAO,EACL,mBAAmB,EACnB,cAAc,GACf,MAA4B,gBAAgB,CAAA;AAE7C,IAAI,CAAC,gBAAgB,EAAE,KAAK,EAAC,CAAC,EAAC,EAAE;IAC/B,MAAM,IAAI;QAER,OAAO,GAAG,EAAE,CAAA;QACZ,gBAAgB,CAAC;KAElB;IAED,MAAM,aAAc,SAAQ,YAAY,CAAC,IAAI,CAAC,EAAiB;QAE7D,EAAE,GAAG,CAAC,CAAA;QACN,gBAAiB,KAAK,EAAE,CAAA,CAAC,CAAC;KAE3B;IAED,MAAM,WAAW,GAAgE,IAAI,CAAA;IACrF,CAAC,CAAC,EAAE,CAAC,WAAW,EAAE,4CAA4C,CAAC,CAAA;IAM/D,MAAM,WAAW,GAGb,IAAI,CAAA;IACR,CAAC,CAAC,EAAE,CAAC,WAAW,EAAE,qCAAqC,CAAC,CAAA;IAGxD,MAAM,QAAQ,GAGV,IAAI,CAAA;IACR,CAAC,CAAC,EAAE,CAAC,QAAQ,EAAE,0CAA0C,CAAC,CAAA;AAC5D,CAAC,CAAC,CAAA;AAEF,IAAI,CAAC,qBAAqB,EAAE,KAAK,EAAC,CAAC,EAAC,EAAE;IACpC,MAAM,IAAI;QAER,OAAO,GAAG,EAAE,CAAA;KAEb;IAED,MAAM,aAAc,SAAQ,cAAc,CACxC,YAAY,CAAC,IAAI,CAAC,EAAiB,CACpC;QAEC,EAAE,GAAG,CAAC,CAAA;QACN,gBAAiB,KAAK,EAAE,CAAA,CAAC,CAAC;KAE3B;IAED,MAAM,UAAU,GAAG,mBAAmB,CAAC,aAAa,CAAC,CAAC,EAAS,CAAC,CAAA;IAChE,MAAM,UAAU,GAAG,mBAAmB,CAAC,aAAa,CAAC,CAAC,EAAS,CAAC,CAAA;IAEhE,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,EAAE,8BAA8B,CAAC,CAAA;IAChE,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,EAAE,8BAA8B,CAAC,CAAA;IAEhE,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;IACtB,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,EAAE,kDAAkD,CAAC,CAAA;IACpF,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,EAAE,kDAAkD,CAAC,CAAA;IAEpF,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;IACtB,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,EAAE,kDAAkD,CAAC,CAAA;IACpF,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,EAAE,kDAAkD,CAAC,CAAA;AACtF,CAAC,CAAC,CAAA;AAEF,IAAI,CAAC,kBAAkB,EAAE,KAAK,EAAC,CAAC,EAAC,EAAE;IAEjC,MAAM,aAAc,SAAQ,cAAc,CACxC,YAAY,CAAC,MAAM,CAAC,EAAiB,CACtC;QAEC,MAAM,CAAC,KAAK,CAAC,OAAO,CAElB,EAAa;YAEb,OAAO,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAA;QACtB,CAAC;QAED,EAAE,GAAG,CAAC,CAAA;QACN,gBAAiB,KAAK,EAAE,CAAA,CAAC,CAAC;KAE3B;IAMD,MAAM,QAAQ,GAGV,IAAI,CAAA;IAER,CAAC,CAAC,EAAE,CAAC,QAAQ,EAAE,sCAAsC,CAAC,CAAA;AACxD,CAAC,CAAC,CAAA"}

package/dist/esm/src/user-mixins/validation.d.ts

@@ -0,0 +1,9 @@
+import type { Constructor } from 'clone-class';
+declare const validationMixin: <MixinBase extends Constructor<{}, {}>>(mixinBase: MixinBase) => <T>() => {
+    new (...args: any[]): {};
+    valid: (o: any) => o is T;
+    validInstance: (target: any) => target is InstanceType<MixinBase>;
+    validInterface: (target: any) => target is T;
+} & MixinBase;
+export { validationMixin, };
+//# sourceMappingURL=validation.d.ts.map

package/dist/esm/src/user-mixins/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../../src/user-mixins/validation.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AAI9C,QAAA,MAAM,eAAe;;eAMQ,GAAG;;;aAoB/B,CAAA;AAED,OAAO,EACL,eAAe,GAChB,CAAA"}

package/dist/esm/src/user-mixins/validation.js

@@ -0,0 +1,26 @@
+import { interfaceOfClass, looseInstanceOfClass, } from 'clone-class';
+import { log } from 'wechaty-puppet';
+const validationMixin = (mixinBase) => () => {
+    log.verbose('ValidationMixin', 'validationMixin(%s)', mixinBase.name);
+    const instanceOfUserClass = looseInstanceOfClass(mixinBase);
+    const interfaceOfUserClass = interfaceOfClass(mixinBase)();
+    const validUserClass = (o) => {
+        if (instanceOfUserClass(o)) {
+            // console.info('instanceOfUserClass(o) true')
+            return true;
+        }
+        else if (interfaceOfUserClass(o)) {
+            // console.info('interfaceOfUserClass(o): true')
+            return true;
+        }
+        return false;
+    };
+    class ValidationUserClass extends mixinBase {
+        static valid = validUserClass;
+        static validInstance = instanceOfUserClass;
+        static validInterface = interfaceOfUserClass;
+    }
+    return ValidationUserClass;
+};
+export { validationMixin, };
+//# sourceMappingURL=validation.js.map

package/dist/esm/src/user-mixins/validation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.js","sourceRoot":"","sources":["../../../../src/user-mixins/validation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAChB,oBAAoB,GACrB,MAAgC,aAAa,CAAA;AAG9C,OAAO,EAAE,GAAG,EAAE,MAAmB,gBAAgB,CAAA;AAEjD,MAAM,eAAe,GAAG,CAAiC,SAAoB,EAAE,EAAE,CAAC,GAAM,EAAE;IACxF,GAAG,CAAC,OAAO,CAAC,iBAAiB,EAAE,qBAAqB,EAAE,SAAS,CAAC,IAAI,CAAC,CAAA;IAErE,MAAM,mBAAmB,GAAK,oBAAoB,CAAC,SAAS,CAAC,CAAA;IAC7D,MAAM,oBAAoB,GAAI,gBAAgB,CAAC,SAAS,CAAC,EAAK,CAAA;IAE9D,MAAM,cAAc,GAAG,CAAC,CAAM,EAAU,EAAE;QACxC,IAAI,mBAAmB,CAAC,CAAC,CAAC,EAAE;YAC1B,8CAA8C;YAC9C,OAAO,IAAI,CAAA;SACZ;aAAM,IAAI,oBAAoB,CAAC,CAAC,CAAC,EAAE;YAClC,gDAAgD;YAChD,OAAO,IAAI,CAAA;SACZ;QACD,OAAO,KAAK,CAAA;IACd,CAAC,CAAA;IAED,MAAM,mBAAoB,SAAQ,SAAS;QAEzC,MAAM,CAAC,KAAK,GAAY,cAAc,CAAA;QACtC,MAAM,CAAC,aAAa,GAAI,mBAAmB,CAAA;QAC3C,MAAM,CAAC,cAAc,GAAG,oBAAoB,CAAA;;IAI9C,OAAO,mBAAmB,CAAA;AAC5B,CAAC,CAAA;AAED,OAAO,EACL,eAAe,GAChB,CAAA"}

package/dist/esm/src/user-mixins/validation.spec.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env -S node --no-warnings --loader ts-node/esm
+export {};
+//# sourceMappingURL=validation.spec.d.ts.map

package/dist/esm/src/user-mixins/validation.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.spec.d.ts","sourceRoot":"","sources":["../../../../src/user-mixins/validation.spec.ts"],"names":[],"mappings":""}