@vyr/service-rpc 0.0.1

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@vyr/service-rpc",
+  "version": "0.0.1",
+  "description": "",
+  "main": "./src/index.ts",
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "vue": "3.5.22",
+    "axios": "^1.7.4",
+    "@vyr/locale": "0.0.1",
+    "@vyr/engine": "0.0.1",
+    "@vyr/service": "0.0.1",
+    "@vyr/service-rpc-universal": "0.0.1"
+  },
+  "files": [
+    "package.json",
+    "src/"
+  ]
+}

package/src/RpcService.ts

@@ -0,0 +1,122 @@
+import axios from 'axios'
+import { Descriptor, Listener } from '@vyr/engine'
+import { Service } from '@vyr/service'
+import { path, tokenKey, topic, Confirm, Message } from '@vyr/service-rpc-universal'
+
+interface RpcServiceConfig {
+    token: string
+    notify: (msg: string) => void
+    confirm: (options: Partial<Confirm>, value?: string) => Promise<Confirm>
+}
+
+const _logout = () => {
+    window.localStorage.removeItem(tokenKey)
+    const location = new URL(window.location.href)
+    location.pathname = '/login.html'
+    window.location.href = location.href
+}
+
+class RpcService extends Service {
+
+    static async login(name: string, password: string) {
+        const data = new Message.rpc.login.RequestMessage(name, password)
+        const res = await axios.post<InstanceType<typeof Message['rpc']['login']['NoticeMessage']>>(Message.rpc.login.Method, data)
+        window.localStorage.setItem(tokenKey, res.data.params.token)
+
+        const location = new URL(window.location.href)
+        location.pathname = '/'
+        window.location.href = location.href
+    }
+
+    static async getUser() {
+        const data = new Message.rpc.getUser.RequestMessage()
+        const res = await axios.get<InstanceType<typeof Message['rpc']['getUser']['NoticeMessage']>>(Message.rpc.getUser.Method, data)
+        return res.data.params.user
+    }
+
+    static getToken() {
+        return window.localStorage.getItem(tokenKey) ?? ''
+    }
+    static setToken(toekn: string) {
+        window.localStorage.setItem(tokenKey, toekn)
+    }
+
+    private _listener = new Listener<{ [k: string]: (msg: Message) => void }>()
+    private confirm
+    private socket: any
+    private needTrigger = false
+    private msgQueue: Message[] = []
+
+    constructor(name: string, config: RpcServiceConfig) {
+        super(name)
+        this.confirm = config.confirm
+        const params = { path, extraHeaders: { authorization: 'Bearer ' + config.token }, autoConnect: false }
+        //@ts-ignore
+        this.socket = new window.io(location.href, params)
+
+        this.socket.on(topic, (content: string) => {
+            const msg = Descriptor.deserialization<Message>(content)
+            if (msg.message !== undefined) return config.notify(msg.message)
+            this._delayTrigger(msg)
+        })
+        this.socket.on('disconnect', () => {
+            this.trigger(Message.rpc.disconnect.Method, new Message.rpc.disconnect.NoticeMessage(this.client))
+        })
+
+        this.listen(Message.rpc.confirm.Method, this._onConfirm)
+    }
+
+    private _onConfirm = async (msg: InstanceType<typeof Message['rpc']['confirm']['NoticeMessage']>) => {
+        const result = await this.confirm(msg.params.config)
+        msg.params.config.value = result.value
+        msg.params.config.success = result.success
+        this.send(msg)
+    }
+
+    private _delayTrigger(msg: Message) {
+        this.msgQueue.push(msg)
+        if (this.needTrigger === true) return
+        this.needTrigger = true
+        setTimeout(() => this._executeMsgQueue(), 160)
+    }
+    private _executeMsgQueue() {
+        this.needTrigger = false
+        for (const msg of this.msgQueue) {
+            this.trigger(msg.method, msg)
+        }
+        this.msgQueue.length = 0
+    }
+
+    get client(): string {
+        return this.socket.id
+    }
+
+    get url(): string {
+        return this.socket.uri
+    }
+
+    async ready() {
+        this.listen(Message.rpc.logout.Method, _logout)
+    }
+
+    async start() {
+        await this.socket.connect()
+    }
+
+    trigger<T extends Message = Message>(method: string, msg: T) {
+        this._listener.trigger(method, msg)
+    }
+    listen<T extends Message = Message>(method: string, cb: (msg: T) => void) {
+        this._listener.listen(method, cb)
+    }
+    unlisten<T extends Message = Message>(method: string, cb: (msg: T) => void) {
+        this._listener.unlisten(method, cb)
+    }
+
+    /**向服务端发送数据 */
+    send(msg: Message) {
+        this.socket.emit(topic, Descriptor.serialization(msg))
+    }
+}
+
+export { RpcService }

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from '@vyr/service-rpc-universal'
+export * from './locale'
+export * from './RpcService'

package/src/locale/Language.ts

@@ -0,0 +1,10 @@
+import { Locale } from "@vyr/locale";
+import { zhCnLanguageProvider, ZhCNLanguageProvider } from "./LanguageProvider";
+
+Locale.register(zhCnLanguageProvider)
+
+const language = Locale.getLanguage<ZhCNLanguageProvider>(zhCnLanguageProvider.name)
+
+export {
+    language
+}

package/src/locale/LanguageProvider.ts

@@ -0,0 +1,15 @@
+import { LanguageProvider } from '@vyr/locale'
+
+interface ZhCNLanguageProvider extends LanguageProvider {
+
+}
+
+const zhCnLanguageProvider: ZhCNLanguageProvider = {
+    id: 'zh_CN',
+    name: '@vyr/service-rpc',
+}
+
+export {
+    ZhCNLanguageProvider,
+    zhCnLanguageProvider,
+}

package/src/locale/index.ts

@@ -0,0 +1,2 @@
+export * from './LanguageProvider'
+export * from './Language'