v0.13.0

Signed-off-by: MiaoWoo <admin@yumc.pw>

lerna.json

@@ -1,5 +1,5 @@
 {
-    "version": "0.10.1",
+    "version": "0.13.0",
     "useWorkspaces": true,
     "npmClient": "yarn",
     "packages": [

packages/amqp/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ccms/amqp",
-    "version": "0.10.1",
+    "version": "0.13.0",
     "description": "MiaoScript amqp package",
     "keywords": [
         "miaoscript",
@@ -19,12 +19,12 @@
         "test": "echo \"Error: run tests from root\" && exit 1"
     },
     "dependencies": {
-        "@ccms/api": "^0.10.1",
-        "@ccms/common": "^0.10.1",
-        "@ccms/container": "^0.10.1"
+        "@ccms/api": "^0.13.0",
+        "@ccms/common": "^0.13.0",
+        "@ccms/container": "^0.13.0"
     },
     "devDependencies": {
-        "@ccms/nashorn": "^0.10.1",
+        "@ccms/nashorn": "^0.13.0",
         "@javatypes/amqp-client": "^0.0.3",
         "@javatypes/spring-amqp": "^0.0.3",
         "@javatypes/spring-rabbit": "^0.0.3",

packages/api/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ccms/api",
-    "version": "0.10.1",
+    "version": "0.13.0",
     "description": "MiaoScript api package",
     "keywords": [
         "miaoscript",
@@ -19,9 +19,9 @@
         "test": "echo \"Error: run tests from root\" && exit 1"
     },
     "dependencies": {
-        "@ccms/common": "^0.10.1",
-        "@ccms/container": "^0.10.1",
-        "@ccms/ployfill": "^0.10.1",
+        "@ccms/common": "^0.13.0",
+        "@ccms/container": "^0.13.0",
+        "@ccms/ployfill": "^0.13.0",
         "base64-js": "^1.5.1",
         "source-map-builder": "^0.0.7"
     },

packages/api/src/console.ts

@@ -27,7 +27,8 @@ export class MiaoScriptConsole implements Console {
     private _level: LogLevel = LogLevel.INFO
 
     protected logger: any
-    protected prefix: string = '§6[§bMiaoScript§6]§r '
+
+    public prefix: string = '§6[§bMiaoScript§6]§r '
 
     constructor(name?: string) {
         this.name = name
@@ -47,10 +48,10 @@ export class MiaoScriptConsole implements Console {
     set name(name: string) {
         if (name) {
             this._name = `[${name}] `
-            // noinspection JSUnusedGlobalSymbols
             this.prefix = `§6[§cMS§6][§b${name}§6]§r `
         }
     }
+
     log(...args: any[]): void {
         this.logger.info(this.name + args.join(' '))
     }
@@ -90,7 +91,7 @@ export class MiaoScriptConsole implements Console {
     ex(ex: Error) {
         this.stack(ex).forEach(line => this.console(line))
     }
-    readSourceMap(fileName: string, lineNumber: number) {
+    readSourceMap(fileName: string, lineNumber: any) {
         try {
             if (fileName.endsWith('js')) {
                 if (MiaoScriptConsole.sourceMaps[fileName] === undefined) {
@@ -153,14 +154,17 @@ export class MiaoScriptConsole implements Console {
             } else {
                 let className = trace.className
                 var fileName = trace.fileName as string
+                var lineNumber = trace.lineNumber
                 if (className.startsWith('jdk.nashorn.internal.scripts')) {
                     className = className.substr(className.lastIndexOf('$') + 1)
-                    var { fileName, lineNumber } = this.readSourceMap(trace.fileName, trace.lineNumber)
+                    var { fileName, lineNumber } = this.readSourceMap(fileName, lineNumber)
                     if (fileName.startsWith(root)) { fileName = fileName.split(root)[1] }
                 } else {
-                    for (let prefix in ignoreLogPrefix) {
-                        if (className.startsWith(ignoreLogPrefix[prefix])) {
-                            return
+                    if (!global.debug) {
+                        for (let prefix in ignoreLogPrefix) {
+                            if (className.startsWith(ignoreLogPrefix[prefix])) {
+                                return
+                            }
                         }
                     }
                 }

packages/api/src/index.ts

@@ -12,4 +12,5 @@ export * from './console'
 export * from './channel'
 export * from './command'
 export * from './database'
+export * from './particle'
 export * from './constants'

packages/api/src/particle.ts

@@ -0,0 +1,494 @@
+import { Autowired, injectable } from '@ccms/container'
+
+import { task, plugin } from './index'
+
+const UUID = Java.type('java.util.UUID')
+const Math = Java.type('java.lang.Math')
+
+export namespace particle {
+    /**
+     * 表示一个特效对象
+     *
+     * @author Zoyn
+     */
+    export abstract class Particle {
+        private spawner: ParticleSpawner
+        private readonly uuid: string
+
+        private particle: any /* Particle */
+        private count: number = 1;
+        private offsetX: number = 0;
+        private offsetY: number = 0;
+        private offsetZ: number = 0;
+        private extra: number = 0;
+        private data: Object = null;
+
+        constructor() {
+            this.uuid = UUID.randomUUID().toString()
+        }
+        abstract show(location: any)
+
+        getUUID() {
+            return this.uuid
+        }
+
+        getSpawner() {
+            return this.spawner
+        }
+
+        setSpawner(spawner: ParticleSpawner) {
+            this.spawner = spawner
+            return this
+        }
+
+        getParticle() {
+            return this.particle
+        }
+
+        setParticle(particle: any, data: any = null) {
+            this.particle = particle
+            this.data = data
+            return this
+        }
+
+        getCount() {
+            return this.count
+        }
+
+        setCount(count: number) {
+            this.count = count
+            return this
+        }
+
+        getOffsetX() {
+            return this.offsetX
+        }
+
+        setOffsetX(offsetX: number) {
+            this.offsetX = offsetX
+            return this
+        }
+
+        getOffsetY() {
+            return this.offsetY
+        }
+
+        setOffsetY(offsetY: number) {
+            this.offsetY = offsetY
+            return this
+        }
+
+        getOffsetZ() {
+            return this.offsetZ
+        }
+
+        setOffsetZ(offsetZ: number) {
+            this.offsetZ = offsetZ
+            return this
+        }
+
+        getExtra() {
+            return this.extra
+        }
+
+        setExtra(extra: number) {
+            this.extra = extra
+            return this
+        }
+
+        getData() {
+            return this.data
+        }
+
+        setData(data) {
+            this.data = data
+            return this
+        }
+
+        /**
+         * 通过给定一个坐标就可以使用已经指定的参数来播放粒子
+         *
+         * @param location 坐标
+         */
+        spawn(location: any) {
+            if (!this.spawner) throw new Error(`particle ${this.uuid} not set spawner can't spawn!`)
+            this.spawner.spawn(location, this)
+        }
+    }
+    /**
+     * 表示一条线
+     *
+     * @author Zoyn
+     */
+    export class Line extends Particle {
+        private vector: any
+        private start: any
+        private end: any
+        /**
+         * 步长
+         */
+        private step: number
+        /**
+         * 向量长度
+         */
+        private length: number
+
+        /**
+         * 构造一条线
+         *
+         * @param start 线的起点
+         * @param end   线的终点
+         */
+        constructor(start: any, end: any)
+        /**
+         * 构造一条线
+         *
+         * @param start  线的起点
+         * @param end    线的终点
+         * @param step   每个粒子之间的间隔 (也即步长)
+         */
+        constructor(start: any, end: any, step: number = 0.1) {
+            super()
+            this.start = start
+            this.end = end
+            this.step = step
+            // 对向量进行重置
+            this.resetVector()
+        }
+
+        show() {
+            for (let i = 0; i < this.length; i += this.step) {
+                let vectorTemp = this.vector.clone().multiply(i)
+                this.spawn(this.start.clone().add(vectorTemp))
+            }
+        }
+
+        /**
+         * 获取线的起始坐标
+         *
+         * @return {@link Location}
+         */
+        getStart() {
+            return this.start
+        }
+
+        /**
+         * 利用给定的坐标设置线的起始坐标
+         *
+         * @param start 起始坐标
+         * @return {@link Line}
+         */
+        setStart(start) {
+            this.start = start
+            this.resetVector()
+            return this
+        }
+
+        /**
+         * 获取线的终点坐标
+         *
+         * @return {@link Location}
+         */
+        getEnd() {
+            return this.end
+        }
+
+        /**
+         * 利用给定的坐标设置线的终点坐标
+         *
+         * @param end 终点
+         * @return {@link Line}
+         */
+        setEnd(end) {
+            this.end = end
+            this.resetVector()
+            return this
+        }
+
+        /**
+         * 获取每个粒子之间的间隔
+         *
+         * @return 也就是循环的步长
+         */
+        getStep() {
+            return this.step
+        }
+
+        /**
+         * 设置每个粒子之间的间隔
+         *
+         * @param step 间隔
+         * @return {@link Line}
+         */
+        setStep(step) {
+            this.step = step
+            this.resetVector()
+            return this
+        }
+
+        /**
+         * 手动重设线的向量
+         */
+        resetVector() {
+            this.vector = this.end.clone().subtract(this.start).toVector()
+            this.length = this.vector.length()
+            this.vector.normalize()
+        }
+
+        public static buildLine(locA: any, locB: any, step: number, particle: any) {
+            let vectorAB = locB.clone().subtract(locA).toVector()
+            let vectorLength = vectorAB.length()
+            vectorAB.normalize()
+            for (let i = 0; i < vectorLength; i += step) {
+                ParticleManager.globalSpawner.spawn(locA.clone().add(vectorAB.clone().multiply(i)), particle)
+            }
+        }
+    }
+    /**
+     * 表示一个弧
+     *
+     * @author Zoyn
+     */
+    export class Arc extends Particle {
+        private angle: number
+        private radius: number
+        private step: number
+
+        /**
+         * 构造一个弧
+         *
+         * @param origin 弧所在的圆的圆点
+         * @param angle  弧所占的角度
+         * @param radius 弧所在的圆的半径
+         * @param step   每个粒子的间隔(也即步长)
+         */
+        constructor(angle: number = 30, radius: number = 1, step: number = 1) {
+            super()
+            this.angle = angle
+            this.radius = radius
+            this.step = step
+        }
+
+        show(location: any) {
+            for (let i = 0; i < this.angle; i += this.step) {
+                let radians: number = Math.toRadians(i)
+                let x: number = this.radius * Math.cos(radians)
+                let z: number = this.radius * Math.sin(radians)
+
+                super.spawn(location.clone().add(x, 0, z))
+            }
+        }
+
+        getAngle(): number {
+            return this.angle
+        }
+
+        setAngle(angle: number): Arc {
+            this.angle = angle
+            return this
+        }
+
+        getRadius(): number {
+            return this.radius
+        }
+
+        setRadius(radius: number): Arc {
+            this.radius = radius
+            return this
+        }
+
+        getStep(): number {
+            return this.step
+        }
+
+        setStep(step: number): Arc {
+            this.step = step
+            return this
+        }
+    }
+    /**
+     * 表示一个圆
+     *
+     * @author Zoyn
+     */
+    export class Circle extends Arc {
+        constructor(radius: number)
+        constructor(radius: number, step: number)
+        /**
+         * 构造一个圆
+         *
+         * @param origin 圆的圆点
+         * @param radius 圆的半径
+         * @param step   每个粒子的间隔(也即步长)
+         * @param period 特效周期(如果需要可以使用)
+         */
+        constructor(radius: number = 1, step: number = 1) {
+            // Circle只需要控制这个fullArc就可以满足所有的要求
+            super(360, radius, step)
+        }
+    }
+    const AtomicInteger = Java.type("java.util.concurrent.atomic.AtomicInteger")
+
+    @injectable()
+    export abstract class ParticleManager {
+        public static globalSpawner: ParticleSpawner = undefined
+        @Autowired()
+        private taskManager: task.TaskManager
+
+        protected taskId: java.util.concurrent.atomic.AtomicInteger
+        protected cacheTasks = new Map<string, ParticleTask>()
+        protected pluginCacheTasks = new Map<string, Map<number, ParticleTask>>()
+
+        constructor() {
+            this.taskId = new AtomicInteger(0)
+        }
+
+        /**
+         * 获得自增的任务ID
+         */
+        public nextId() {
+            return this.taskId.incrementAndGet()
+        }
+
+        public getTaskManager() {
+            return this.taskManager
+        }
+
+        public create(particle: Particle, plugin?: plugin.Plugin) {
+            let uuid = particle.getUUID()
+            if (this.cacheTasks.has(uuid)) {
+                return this.cacheTasks.get(uuid)
+            }
+            let task = this.create0(plugin, particle)
+            this.cacheTasks.set(uuid, task)
+            if (plugin) {
+                if (!this.pluginCacheTasks.has(plugin.description.name)) {
+                    this.pluginCacheTasks.set(plugin.description.name, new Map())
+                }
+                this.pluginCacheTasks.get(plugin.description.name).set(task.getTaskId(), task)
+            }
+            return task
+        }
+
+        public cancel(particle: Particle) {
+            let uuid = particle.getUUID()
+            if (this.cacheTasks.has(uuid)) {
+                this.cacheTasks.get(uuid).cancel()
+                this.cacheTasks.delete(uuid)
+            } else {
+                throw new Error(`particle ${uuid} not found!`)
+            }
+        }
+
+        disable(plugin: plugin.Plugin) {
+            if (this.pluginCacheTasks.has(plugin.description.name)) {
+                this.pluginCacheTasks
+                    .get(plugin.description.name)
+                    .forEach((task) => task.cancel())
+                this.pluginCacheTasks.delete(plugin.description.name)
+            }
+        }
+        protected create0(owner: plugin.Plugin, particle: Particle): ParticleTask {
+            particle.setSpawner(this.getGlobalSpawner())
+            return new ParticleTask(owner, particle, this)
+        }
+        protected abstract getGlobalSpawner(): ParticleSpawner
+    }
+
+    export class ParticleTask {
+
+        private particle: Particle
+        private isAsync: boolean = false
+        private interval: number = 0
+        private _location: any
+        private _follow: any
+
+        private owner: plugin.Plugin
+        private taskId: number
+        private task: task.Task
+        private taskManager: task.TaskManager
+        protected particleManager: ParticleManager
+
+        constructor(owner: plugin.Plugin, particle: Particle, particleManager: ParticleManager) {
+            this.owner = owner
+            this.taskId = particleManager.nextId()
+            this.particle = particle
+            this.taskManager = particleManager.getTaskManager()
+            this.particleManager = particleManager
+        }
+
+        getOwner() {
+            return this.task.getOwner()
+        }
+
+        getTaskId() {
+            return this.taskId
+        }
+
+        getParticle() {
+            return this.particle
+        }
+
+        async(isAsync: boolean = true) {
+            this.isAsync = isAsync
+            return this
+        }
+
+        timer(tick: number) {
+            this.interval = tick
+            return this
+        }
+
+        follow(entity: { getLocation: () => any }) {
+            this._follow = entity
+            this._location = undefined
+            return this
+        }
+
+        location(location: any) {
+            this._location = location
+            this._follow = undefined
+            return this
+        }
+
+        submit() {
+            this.cancel()
+            if (this._follow && !this.interval) throw new Error(`enable follow entity but interval is ${this.interval}!`)
+            this.taskManager.create(() => {
+                this.task = this.taskManager
+                    .create(() => {
+                        try {
+                            if (this._follow) {
+                                if (!this._follow.isOnline()) return this.cancel()
+                                this.particle.show(this._follow.getLocation().clone().add(0, 1, 0))
+                            } else if (this._location) {
+                                this.particle.show(this._location)
+                            } else {
+                                console.warn(`ParticleTask ${this.taskId} particle ${this.particle.getUUID()} cancel because entity and location both undefined!`)
+                                this.task.cancel()
+                            }
+                        } catch (error) {
+                            console.error(`§6插件 §a${this.owner.description.name} §c播放粒子发送异常 §4粒子播放任务已终止!`)
+                            console.ex(error)
+                            this.cancel()
+                        }
+                    }, this.owner)
+                    .async(this.isAsync)
+                    .timer(this.interval)
+                    .submit()
+            }, this.owner).later(2).submit()
+            return this
+        }
+
+        cancel() {
+            if (this.task != null) {
+                this.task.cancel()
+            }
+        }
+    }
+
+    export abstract class ParticleSpawner {
+        abstract spawnParticle(location: any, particle: any, count: number)
+        abstract spawn(location: any, particle: Particle)
+    }
+}

packages/api/src/server.ts

@@ -18,9 +18,15 @@ export namespace server {
     export const ServerInstance = Symbol("ServerInstance")
     @injectable()
     export abstract class NativePluginManager {
+        list(): any[] {
+            throw new Error("Method not implemented.")
+        }
         has(name: string): boolean {
             return true
         }
+        get(name: string): any {
+            throw new Error("Method not implemented.")
+        }
         load(name: string): boolean {
             throw new Error("Method not implemented.")
         }

packages/api/src/task.ts

@@ -152,7 +152,7 @@ export namespace task {
          * 提交任务
          * @param args 任务参数
          */
-        submit(...args: any[]): Cancelable {
+        submit(...args: any[]): task.Task {
             this.innerTask = this.submit0(...args)
             return this
         }

packages/bukkit/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ccms/bukkit",
-    "version": "0.10.1",
+    "version": "0.13.0",
     "description": "MiaoScript bukkit package",
     "keywords": [
         "miaoscript",
@@ -25,8 +25,8 @@
         "typescript": "^4.0.5"
     },
     "dependencies": {
-        "@ccms/api": "^0.10.1",
-        "@ccms/common": "^0.10.1",
-        "@ccms/container": "^0.10.1"
+        "@ccms/api": "^0.13.0",
+        "@ccms/common": "^0.13.0",
+        "@ccms/container": "^0.13.0"
     }
 }

packages/bukkit/src/index.ts

@@ -8,9 +8,12 @@ import './chat'
 import './task'
 import './event'
 import './server'
+import { BukkitNativePluginManager } from './plugin'
 import './command'
 import './channel'
+import './particle'
 
 export default function BukkitImpl(container: Container) {
     container.bind(server.Console).toConstantValue(BukkitConsole)
+    container.rebind(server.NativePluginManager).toConstantValue(new BukkitNativePluginManager())
 }

packages/bukkit/src/particle.ts

@@ -0,0 +1,31 @@
+import { provideSingleton } from '@ccms/container'
+import { particle, plugin } from '@ccms/api'
+
+@provideSingleton(particle.ParticleManager)
+export class BukkitParticleManager extends particle.ParticleManager {
+    private globalSpawner = new BukkitParticleSpawner()
+    constructor() {
+        super()
+        particle.ParticleManager.globalSpawner = this.globalSpawner
+    }
+    protected getGlobalSpawner() {
+        return this.globalSpawner
+    }
+}
+export class BukkitParticleSpawner extends particle.ParticleSpawner {
+    spawnParticle(location: any, particle: any, count: number = 1) {
+        location.getWorld().spawnParticle(particle, location, count)
+    }
+    spawn(location: any, particle: particle.Particle) {
+        location.getWorld().spawnParticle(
+            particle.getParticle(),
+            location,
+            particle.getCount(),
+            particle.getOffsetX(),
+            particle.getOffsetY(),
+            particle.getOffsetZ(),
+            particle.getExtra(),
+            particle.getData()
+        )
+    }
+}

packages/bukkit/src/plugin.ts

@@ -0,0 +1,12 @@
+import { server } from '@ccms/api'
+
+const Bukkit = org.bukkit.Bukkit
+
+export class BukkitNativePluginManager extends server.NativePluginManager {
+    has(name: string) {
+        return !!this.get(name)
+    }
+    get(name: string) {
+        return Bukkit.getPluginManager().getPlugin(name)
+    }
+}

packages/bungee/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ccms/bungee",
-    "version": "0.10.1",
+    "version": "0.13.0",
     "description": "MiaoScript bungee package",
     "keywords": [
         "miaoscript",
@@ -25,8 +25,8 @@
         "typescript": "^4.0.5"
     },
     "dependencies": {
-        "@ccms/api": "^0.10.1",
-        "@ccms/common": "^0.10.1",
-        "@ccms/container": "^0.10.1"
+        "@ccms/api": "^0.13.0",
+        "@ccms/common": "^0.13.0",
+        "@ccms/container": "^0.13.0"
     }
 }

packages/bungee/src/index.ts

@@ -3,13 +3,15 @@
 import { server } from '@ccms/api'
 import { Container } from '@ccms/container'
 
-import { BungeeConsole } from './console';
-import './event';
-import './server';
-import './command';
-import './channel';
-import './task';
+import { BungeeConsole } from './console'
+import './task'
+import './event'
+import './server'
+import { BungeeNativePluginManager } from './plugin'
+import './command'
+import './channel'
 
 export default function BungeeImpl(container: Container) {
-    container.bind(server.Console).toConstantValue(BungeeConsole);
+    container.bind(server.Console).toConstantValue(BungeeConsole)
+    container.rebind(server.NativePluginManager).toConstantValue(new BungeeNativePluginManager())
 }

packages/bungee/src/plugin.ts

@@ -0,0 +1,12 @@
+import { server } from '@ccms/api'
+
+let Bungee: net.md_5.bungee.api.ProxyServer = base.getInstance().getProxy()
+
+export class BungeeNativePluginManager extends server.NativePluginManager {
+    has(name: string) {
+        return !!this.get(name)
+    }
+    get(name: string) {
+        return Bungee.getPluginManager().getPlugin(name)
+    }
+}

packages/client/package.json

@@ -1,7 +1,7 @@
 {
     "private": true,
     "name": "@ccms/client",
-    "version": "0.10.1",
+    "version": "0.13.0",
     "description": "MiaoScript client package",
     "keywords": [
         "miaoscript",

packages/common/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ccms/common",
-    "version": "0.10.1",
+    "version": "0.13.0",
     "description": "MiaoScript api package",
     "keywords": [
         "miaoscript",
@@ -19,7 +19,7 @@
         "test": "echo \"Error: run tests from root\" && exit 1"
     },
     "devDependencies": {
-        "@ccms/nashorn": "^0.10.1",
+        "@ccms/nashorn": "^0.13.0",
         "@javatypes/jdk": "^0.0.3",
         "reflect-metadata": "^0.1.13",
         "rimraf": "^3.0.2",

packages/compile/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ccms/compile",
-    "version": "0.10.1",
+    "version": "0.13.0",
     "description": "MiaoScript compile package",
     "keywords": [
         "miaoscript",

packages/container/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ccms/container",
-    "version": "0.10.1",
+    "version": "0.13.0",
     "description": "MiaoScript container package",
     "keywords": [
         "miaoscript",
@@ -19,7 +19,7 @@
         "test": "echo \"Error: run tests from root\" && exit 1"
     },
     "devDependencies": {
-        "@ccms/nashorn": "^0.10.1",
+        "@ccms/nashorn": "^0.13.0",
         "reflect-metadata": "^0.1.13",
         "rimraf": "^3.0.2",
         "typescript": "^4.0.5"

packages/core/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ccms/core",
-    "version": "0.10.1",
+    "version": "0.13.0",
     "description": "MiaoScript api package",
     "keywords": [
         "miaoscript",
@@ -24,8 +24,8 @@
         "typescript": "^4.0.5"
     },
     "dependencies": {
-        "@ccms/api": "^0.10.1",
-        "@ccms/container": "^0.10.1"
+        "@ccms/api": "^0.13.0",
+        "@ccms/container": "^0.13.0"
     },
     "gitHead": "781524f83e52cad26d7c480513e3c525df867121"
 }

packages/core/src/index.ts

@@ -1,25 +1,23 @@
 let containerStartTime = Date.now()
 console.i18n("ms.core.ioc.initialize", { scope: global.scope })
 import { plugin, server, task, constants } from '@ccms/api'
-import { DefaultContainer as container, inject, provideSingleton, ContainerInstance, buildProviderModule } from '@ccms/container'
+import { DefaultContainer as container, inject, provideSingleton, ContainerInstance, buildProviderModule, Autowired } from '@ccms/container'
 console.i18n("ms.core.ioc.completed", { scope: global.scope, time: (Date.now() - containerStartTime) / 1000 })
 import http from '@ccms/common/dist/http'
 
 @provideSingleton(MiaoScriptCore)
 class MiaoScriptCore {
-    @inject(server.Console)
+    @Autowired(server.Console)
     private Console: Console
-    @inject(task.TaskManager)
-    private taskManager: task.TaskManager
-    @inject(plugin.PluginFolder)
+    @Autowired(plugin.PluginFolder)
     private pluginFolder: string
-    @inject(plugin.PluginManager)
+    @Autowired()
+    private taskManager: task.TaskManager
+    @Autowired()
     private pluginManager: plugin.PluginManager
 
     enable() {
         this.loadServerConsole()
-        this.loadTaskFunction()
-        global.level = "TRACE"
         this.loadPlugins()
         return () => this.disable()
     }
@@ -29,15 +27,6 @@ class MiaoScriptCore {
         global.setGlobal('console', new this.Console(), { writable: false, configurable: false })
     }
 
-    loadTaskFunction() {
-        global.setGlobal('setTimeout', (func: Function, tick: number, ...args: any[]) => {
-            return this.taskManager.create(func).later(tick).submit(...args)
-        }, { writable: false, configurable: false })
-        global.setGlobal('setInterval', (func: Function, tick: number, ...args: any[]) => {
-            return this.taskManager.create(func).timer(tick).submit(...args)
-        }, { writable: false, configurable: false })
-    }
-
     loadPlugins() {
         let loadPluginStartTime = new Date().getTime()
         console.i18n("ms.core.plugin.initialize")

packages/database/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ccms/database",
-    "version": "0.10.1",
+    "version": "0.13.0",
     "description": "MiaoScript database package",
     "keywords": [
         "miaoscript",
@@ -25,7 +25,7 @@
         "typescript": "^4.0.5"
     },
     "dependencies": {
-        "@ccms/api": "^0.10.1",
-        "@ccms/container": "^0.10.1"
+        "@ccms/api": "^0.13.0",
+        "@ccms/container": "^0.13.0"
     }
 }

packages/i18n/languages/en.yml

@@ -31,7 +31,8 @@ ms.api.command.tab.completer.error: "§6Player {player} §6exec §b{plugin} §6P
 
 ms.plugin.initialize: "Initialization MiaoScript Plugin System: Plugin: {plugin} Loader: {loader}..."
 ms.plugin.event.map: "Total {count} {type} Event Mapping Complate..."
-ms.plugin.manager.scan: "Scanning Plugins in {folder} ..."
+ms.plugin.manager.scan: "Scanner {scanner} Scanning Plugins in {folder} ..."
+ms.plugin.manager.scan.finish: "Scanner {scanner} Found {size} Plugins in {folder} Start Build..."
 ms.plugin.manager.initialize.error: "§6Plugin §b{name} §6initialize error §4{ex}"
 ms.plugin.manager.stage: "{stage} {plugin} version {version} by {author}"
 ms.plugin.manager.stage.exec: "[{plugin}] Exec {name} Stage {stage} When servers is {servers}..."
@@ -39,6 +40,7 @@ ms.plugin.manager.stage.exec.error: "§6Plugin §b{plugin} §6exec §d{executor}
 ms.plugin.manager.stage.load: "Loading"
 ms.plugin.manager.stage.enable: "Enabling"
 ms.plugin.manager.stage.disable: "Disabling"
+ms.plugin.manager.build: "Plugin {name}({version}) Build Finish source: {file}({scanner}) loader: {loader} Cost: {cost}s."
 ms.plugin.manager.build.error: "§6Load Plugin From §b{file} §6failed. §4Error: §c{error}"
 ms.plugin.manager.build.update: "Auto Update Plugin {name} ..."
 ms.plugin.manager.build.not.extends: "§4Found error plugin §b{source} §4it's not extends interfaces.Plugin, the plugin will be ignore!"

packages/i18n/languages/zh_cn.yml

@@ -32,7 +32,8 @@ ms.api.command.tab.completer.error: "§6玩家 §a{player} §6执行 §b{plugin}
 
 ms.plugin.initialize: "初始化 MiaoScript 插件系统: 实例: {plugin} 加载器: {loader}..."
 ms.plugin.event.map: "总计 {count} 个 {type} 事件 映射完成..."
-ms.plugin.manager.scan: "扫描 {folder} 文件夹中插件..."
+ms.plugin.manager.scan: "扫描器 {scanner} 扫描 {folder} 中的插件..."
+ms.plugin.manager.scan.finish: "扫描器 {scanner} 在 {folder} 中 发现 {size} 个插件 开始构建..."
 ms.plugin.manager.initialize.error: "§6插件 §b{name} §6初始化错误 §4{ex}"
 ms.plugin.manager.stage: "{stage} {plugin} 版本 {version} 作者 {author}"
 ms.plugin.manager.stage.exec: "[{plugin}] 执行 {stage} 阶段函数 {name} 匹配类型 {servers}..."
@@ -40,6 +41,7 @@ ms.plugin.manager.stage.exec.error: "§6插件 §b{plugin} §6执行 §d{executo
 ms.plugin.manager.stage.load: "加载"
 ms.plugin.manager.stage.enable: "启用"
 ms.plugin.manager.stage.disable: "关闭"
+ms.plugin.manager.build: "插件 {name}({version}) 构建完成 来源: {file}({scanner}) 引导: {loader} 构建耗时: {cost}s."
 ms.plugin.manager.build.error: "§6从文件 §b{file} §6加载插件失败 §4错误: §c{error}"
 ms.plugin.manager.build.update: "自动更新插件 {name} ..."
 ms.plugin.manager.build.not.extends: "§4发现错误的插件 §b{source} §4未继承接口 interfaces.Plugin, 将不会被载入到服务器!"

packages/i18n/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ccms/i18n",
-    "version": "0.10.1",
+    "version": "0.13.0",
     "description": "MiaoScript i18n package",
     "keywords": [
         "miaoscript",
@@ -19,7 +19,7 @@
         "test": "echo \"Error: run tests from root\" && exit 1"
     },
     "devDependencies": {
-        "@ccms/nashorn": "^0.10.1",
+        "@ccms/nashorn": "^0.13.0",
         "@types/js-yaml": "^3.12.5",
         "reflect-metadata": "^0.1.13",
         "rimraf": "^3.0.2",

packages/i18n/src/index.ts

@@ -1,13 +1,13 @@
 /// <reference types="@ccms/nashorn" />
 import * as yaml from 'js-yaml'
 
-const File = Java.type("java.io.File");
-const separatorChar = File.separatorChar;
+const File = Java.type("java.io.File")
+const separatorChar = File.separatorChar
 type TranslateParam = { [key: string]: any }
 
 declare global {
     interface Console {
-        i18n(name: string, param?: TranslateParam);
+        i18n(name: string, param?: TranslateParam)
     }
 }
 
@@ -23,20 +23,20 @@ export class Translate {
 
     constructor(root: string | TranslateContent) {
         if (typeof root == 'string') {
-            this.root = root;
+            this.root = root
         } else {
-            this.langMap = root.langMap;
-            this.fallbackMap = root.fallbackMap || {};
+            this.langMap = root.langMap
+            this.fallbackMap = root.fallbackMap || {}
         }
     }
 
     translate(name: string, param?: TranslateParam) {
-        let langText: string = this.langMap[name] || this.fallbackMap[name];
+        let langText: string = this.langMap[name] || this.fallbackMap[name]
         if (!langText) { return '[WARN] @ccms/i18n miss lang translate: ' + name }
         for (const key in param) {
             langText = langText.replace(new RegExp("{" + key + "}", 'gm'), param[key])
         }
-        return langText;
+        return langText
     }
 
     initialize(lang: string = 'zh_cn', fallback: string = 'zh_cn') {
@@ -49,7 +49,7 @@ export class Translate {
     }
 
     readYamlFile(dir: string, name: string) {
-        let langFile = this.concat(dir, 'languages', name + '.yml');
+        let langFile = this.concat(dir, 'languages', name + '.yml')
         return this.exists(langFile) && yaml.safeLoad(base.read(langFile))
     }
 

packages/keyvalue/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ccms/keyvalue",
-    "version": "0.10.1",
+    "version": "0.13.0",
     "description": "MiaoScript keyvalue package",
     "keywords": [
         "miaoscript",
@@ -19,12 +19,12 @@
         "test": "echo \"Error: run tests from root\" && exit 1"
     },
     "dependencies": {
-        "@ccms/api": "^0.10.1",
-        "@ccms/common": "^0.10.1",
-        "@ccms/container": "^0.10.1"
+        "@ccms/api": "^0.13.0",
+        "@ccms/common": "^0.13.0",
+        "@ccms/container": "^0.13.0"
     },
     "devDependencies": {
-        "@ccms/nashorn": "^0.10.1",
+        "@ccms/nashorn": "^0.13.0",
         "@javatypes/amqp-client": "^0.0.3",
         "@javatypes/spring-amqp": "^0.0.3",
         "@javatypes/spring-rabbit": "^0.0.3",

packages/nashorn/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ccms/nashorn",
-    "version": "0.10.1",
+    "version": "0.13.0",
     "description": "MiaoScript api package",
     "keywords": [
         "miaoscript",

packages/nashorn/src/index.ts

@@ -67,12 +67,14 @@ declare global {
     interface Core {
         getClass(name: String): any
         getProxyClass(): any
+        getJavaScriptTaskClass(): any
         getInstance(): any
         read(path: string): string
         save(path: string, content: string): void
         delete(path: string): void
     }
     interface Console {
+        prefix: string
         ex(err: Error): void
         stack(err: Error, color?: boolean): string[]
         sender(sender: any, ...args: any): void

packages/nodejs/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ccms/nodejs",
-    "version": "0.10.1",
+    "version": "0.13.0",
     "description": "MiaoScript nodejs package",
     "keywords": [
         "miaoscript",
@@ -19,7 +19,7 @@
         "test": "echo \"Error: run tests from root\" && exit 1"
     },
     "devDependencies": {
-        "@ccms/nashorn": "^0.10.1",
+        "@ccms/nashorn": "^0.13.0",
         "reflect-metadata": "^0.1.13",
         "rimraf": "^3.0.2",
         "typescript": "^4.0.5"

packages/nukkit/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ccms/nukkit",
-    "version": "0.10.1",
+    "version": "0.13.0",
     "description": "MiaoScript nukkit package",
     "keywords": [
         "miaoscript",
@@ -25,8 +25,8 @@
         "typescript": "^4.0.5"
     },
     "dependencies": {
-        "@ccms/api": "^0.10.1",
-        "@ccms/common": "^0.10.1",
-        "@ccms/container": "^0.10.1"
+        "@ccms/api": "^0.13.0",
+        "@ccms/common": "^0.13.0",
+        "@ccms/container": "^0.13.0"
     }
 }

packages/nukkit/src/index.ts

@@ -3,12 +3,14 @@
 import { server } from '@ccms/api'
 import { Container } from '@ccms/container'
 
-import { NukkitConsole } from './console';
-import './event';
-import './server';
-import './command';
-import './task';
+import { NukkitConsole } from './console'
+import './task'
+import './event'
+import './server'
+import { NukkitNativePluginManager } from './plugin'
+import './command'
 
 export default function NukkitImpl(container: Container) {
-    container.bind(server.Console).toConstantValue(NukkitConsole);
+    container.bind(server.Console).toConstantValue(NukkitConsole)
+    container.bind(server.NativePluginManager).toConstantValue(new NukkitNativePluginManager())
 }

packages/nukkit/src/plugin.ts

@@ -0,0 +1,12 @@
+import { server } from '@ccms/api'
+
+let Nukkit: cn.nukkit.Server = base.getInstance().getServer()
+
+export class NukkitNativePluginManager extends server.NativePluginManager {
+    has(name: string) {
+        return !!this.get(name)
+    }
+    get(name: string) {
+        return Nukkit.getPluginManager().getPlugin(name)
+    }
+}

packages/ployfill/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ccms/ployfill",
-    "version": "0.10.1",
+    "version": "0.13.0",
     "description": "MiaoScript ployfill package",
     "author": "MiaoWoo <admin@yumc.pw>",
     "homepage": "https://github.com/circlecloud/ms.git",
@@ -14,12 +14,12 @@
         "test": "echo \"Error: run tests from root\" && exit 1"
     },
     "dependencies": {
-        "@ccms/i18n": "^0.10.1",
-        "@ccms/nodejs": "^0.10.1",
+        "@ccms/i18n": "^0.13.0",
+        "@ccms/nodejs": "^0.13.0",
         "core-js": "^3.7.0"
     },
     "devDependencies": {
-        "@ccms/nashorn": "^0.10.1",
+        "@ccms/nashorn": "^0.13.0",
         "reflect-metadata": "^0.1.13",
         "rimraf": "^3.0.2",
         "typescript": "^4.0.5"

packages/ployfill/src/index.ts

@@ -4,9 +4,9 @@ import i18n from '@ccms/i18n'
 let ployfillStartTime = new Date().getTime()
 i18n.initialize()
 console.i18n("ms.ployfill.initialize")
-require('./es5-ext')
-require('./node-shim')
-require('core-js')
+import './es5-ext'
+import './node-shim'
+import 'core-js'
 //@ts-ignore
 process.on('exit', () => require.disable())
 global.setGlobal('Proxy', require('./proxy').Proxy)

packages/ployfill/src/node-shim.ts

@@ -1,27 +1,41 @@
 import { EventEmitter } from 'events'
 
+const System = Java.type('java.lang.System')
 const Thread = Java.type('java.lang.Thread')
+const Runnable = Java.type('java.lang.Runnable')
+const InterruptedException = Java.type('java.lang.InterruptedException')
 const ThreadGroup = Java.type("java.lang.ThreadGroup")
 const AtomicInteger = Java.type("java.util.concurrent.atomic.AtomicInteger")
+const Callable = Java.type('java.util.concurrent.Callable')
+const ThreadFactory = Java.type("java.util.concurrent.ThreadFactory")
+const TimeoutException = Java.type('java.util.concurrent.TimeoutException')
 const ThreadPoolExecutor = Java.type('java.util.concurrent.ThreadPoolExecutor')
 const LinkedBlockingQueue = Java.type("java.util.concurrent.LinkedBlockingQueue")
+const TimeUnit = Java.type('java.util.concurrent.TimeUnit')
+const DelayQueue = Java.type('java.util.concurrent.DelayQueue')
+const JavaScriptTask = Java.type(base.getJavaScriptTaskClass().name)
 
 const threadCount = new AtomicInteger(0)
 const threadGroup = new ThreadGroup("@ccms/ployfill-micro-task")
 const microTaskPool = new ThreadPoolExecutor(
-    10, 100, 60, Packages.java.util.concurrent.TimeUnit.SECONDS,
-    new LinkedBlockingQueue(500),
-    (run: any) => new Thread(threadGroup, run, "@ccms/micro-task-" + threadCount.incrementAndGet()),
-    new ThreadPoolExecutor.CallerRunsPolicy()
+    100, 200, 60, TimeUnit.SECONDS,
+    new LinkedBlockingQueue(300),
+    new ThreadFactory((run: any) => new Thread(threadGroup, run, "@ccms/micro-task-" + threadCount.incrementAndGet()))
 )
-
 class Process extends EventEmitter {
     env = {
         __noSuchProperty__: (prop) => {
-            return Packages.java.lang.System.getenv(prop)
+            return System.getenv(prop)
         }
     }
-    platform = Packages.java.lang.System.getProperty("os.name")
+    platform = System.getProperty("os.name")
+    constructor() {
+        super()
+        this.on('exit', () => {
+            console.log(`await microTaskPool termination! queueTask: ${microTaskPool.shutdownNow().size()} remainTask: ${threadGroup.activeCount()}`)
+            microTaskPool.awaitTermination(3000, TimeUnit.MILLISECONDS)
+        })
+    }
     on(event: string | symbol, listener: (...args: any[]) => void) {
         return super.on(event, (...args) => {
             try {
@@ -38,13 +52,152 @@ class Process extends EventEmitter {
     nextTick(func: Function) {
         microTaskPool.execute(func)
     }
-    queueMicrotask(func: Function) {
-        microTaskPool.execute(func)
-    }
     exit(code: number) {
-        process.emit('exit', code)
-        microTaskPool.shutdown()
+        console.log(`process exit by code ${code}!`)
+        this.emit('exit', code)
+    }
+}
+
+class EventLoop {
+    private eventLoopMainThread = undefined
+    private eventLoopTaskQueue = new DelayQueue()
+    private taskExecTimeout = 3
+    private fixedThreadPool = undefined
+
+    constructor() {
+        this.taskExecTimeout = parseInt(process.env.MS_NODE_EVENT_LOOP_TIMEOUT) || 3
+        this.fixedThreadPool = new ThreadPoolExecutor(
+            1, 1, 0, TimeUnit.SECONDS,
+            new LinkedBlockingQueue(300),
+            new ThreadFactory((run: any) => {
+                let thread = new Thread(run, "@ccms/node-shim/event-loop-exec")
+                thread.setDaemon(true)
+                return thread
+            }))
+        this.eventLoopMainThread = new Thread(() => {
+            let task = undefined
+            try {
+                while (!this.eventLoopMainThread.isInterrupted()) {
+                    task = this.eventLoopTaskQueue.take()
+                    try {
+                        task.getTask()()
+                    } catch (cause) {
+                        try {
+                            process.emit('error', cause)
+                        } catch (error) {
+                            console.error(cause)
+                            console.ex(cause)
+                        }
+                    }
+                }
+            } catch (error) {
+                console.log(`EventLoop Thread isInterrupted exit! remainTask: ${this.eventLoopTaskQueue.size()}`)
+                this.eventLoopTaskQueue.clear()
+                this.eventLoopTaskQueue = undefined
+                this.timeoutCount = undefined
+                this.timeoutTasks = undefined
+                this.intervalCount = undefined
+                this.intervalTasks = undefined
+                this.eventLoopMainThread = undefined
+            }
+        }, "@ccms/node-shim/event-loop")
+        this.eventLoopMainThread.setDaemon(true)
+        process.on('exit', () => {
+            this.eventLoopMainThread.interrupt()
+            this.fixedThreadPool.shutdownNow()
+            console.log(`await fixedThreadPool termination!`)
+            this.fixedThreadPool.awaitTermination(3000, TimeUnit.MILLISECONDS)
+        })
+    }
+
+    startEventLoop() {
+        this.eventLoopMainThread.start()
+    }
+
+    private putDelayTask(id: number, callback: Function, ms: number) {
+        this.eventLoopTaskQueue.put(new JavaScriptTask(id, callback, ms))
+    }
+
+    private limitTimeTask(name: string, callback: Function, ...args: any[]) {
+        if (!callback) {
+            throw new Error(`task ${name} callback function can't be null!`)
+        }
+        if (this.fixedThreadPool.isShutdown()) { return console.warn(`FixedThreadPool isTerminated! ignore Task ${name}!`) }
+        try {
+            this.fixedThreadPool.submit(new Callable({
+                call: () => {
+                    try {
+                        callback.apply(undefined, args)
+                    } catch (cause) {
+                        cause = cause.getCause && cause.getCause() || cause
+                        try {
+                            process.emit('error', cause)
+                        } catch (error) {
+                            console.error(cause)
+                            console.ex(cause)
+                        }
+                    }
+                }
+            })).get(this.taskExecTimeout, TimeUnit.SECONDS)
+        } catch (error) {
+            if (error instanceof InterruptedException) {
+                return console.warn(`FixedThreadPool isInterrupted exit! Task ${name} exec exit!`)
+            }
+            if (error instanceof TimeoutException) {
+                return console.warn(`Task ${name} => ${callback} exec time greater than ${this.taskExecTimeout}s!`)
+            }
+            throw error.getCause && error.getCause() || error
+        }
+    }
+
+    private timeoutCount = new AtomicInteger(0)
+    private timeoutTasks = []
+    setTimeout(callback: (...args: any[]) => void, ms: number, ...args: any[]) {
+        let taskId = this.timeoutCount.incrementAndGet()
+        this.timeoutTasks[taskId] = callback
+        console.trace(`create setTimeout task ${taskId} => ${callback}`)
+        this.putDelayTask(taskId, () => {
+            if (this.timeoutTasks[taskId]) {
+                this.limitTimeTask(`setTimeout-${taskId}`, callback, ...args)
+            } else {
+                console.trace(`ignore setTimeout ${ms}ms task ${taskId} because it's cancelled!`)
+            }
+        }, ms)
+        return taskId
+    }
+    clearTimeout(taskId: number) {
+        delete this.timeoutTasks[taskId]
+    }
+
+    private intervalCount = new AtomicInteger(0)
+    private intervalTasks = []
+    setInterval(callback: (...args: any[]) => void, ms: number, ...args: any[]) {
+        let taskId = this.intervalCount.incrementAndGet()
+        this.intervalTasks[taskId] = callback
+        console.trace(`create setInterval ${ms}ms task ${taskId} => ${callback}`)
+        let intervalTask = () => {
+            if (this.intervalTasks[taskId]) {
+                this.limitTimeTask(`setInterval-${taskId}`, callback, ...args)
+                this.putDelayTask(taskId, intervalTask, ms)
+            } else {
+                console.trace(`ignore setInterval task ${taskId} because it's cancelled!`)
+            }
+        }
+        this.putDelayTask(taskId, intervalTask, ms)
+        return taskId
+    }
+    clearInterval(taskId: number) {
+        delete this.intervalTasks[taskId]
     }
 }
 global.setGlobal('process', new Process(), {})
+const eventLoop = new EventLoop()
+global.setGlobal('eventLoop', eventLoop, {})
+eventLoop.startEventLoop()
 global.setGlobal('queueMicrotask', (func: any) => microTaskPool.execute(func), {})
+global.setGlobal('setTimeout', eventLoop.setTimeout.bind(eventLoop), {})
+global.setGlobal('clearTimeout', eventLoop.clearTimeout.bind(eventLoop), {})
+global.setGlobal('setInterval', eventLoop.setInterval.bind(eventLoop), {})
+global.setGlobal('clearInterval', eventLoop.clearInterval.bind(eventLoop), {})
+global.setGlobal('setImmediate', (callback: (...args: any[]) => void, ...args: any[]) => eventLoop.setTimeout(callback, 0, ...args), { writable: true })
+global.setGlobal('clearImmediate ', eventLoop.clearTimeout.bind(eventLoop), { writable: true })

packages/plugin/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ccms/plugin",
-    "version": "0.10.1",
+    "version": "0.13.0",
     "description": "MiaoScript api package",
     "keywords": [
         "miaoscript",
@@ -25,10 +25,10 @@
         "typescript": "^4.0.5"
     },
     "dependencies": {
-        "@ccms/api": "^0.10.1",
-        "@ccms/common": "^0.10.1",
-        "@ccms/container": "^0.10.1",
-        "@ccms/i18n": "^0.10.1",
+        "@ccms/api": "^0.13.0",
+        "@ccms/common": "^0.13.0",
+        "@ccms/container": "^0.13.0",
+        "@ccms/i18n": "^0.13.0",
         "js-yaml": "^3.14.0"
     }
 }

packages/plugin/src/command.ts

@@ -1,5 +1,6 @@
 import { command, plugin, server } from '@ccms/api'
 import { provideSingleton, Autowired } from '@ccms/container'
+import { interfaces } from './interfaces'
 import { getPluginCommandMetadata, getPluginTabCompleterMetadata } from './utils'
 
 @provideSingleton(PluginCommandManager)
@@ -23,11 +24,10 @@ export class PluginCommandManager {
                 continue
             }
             for (let command of [cmd.name, ...cmd.alias]) {
+                let [cmdExecutor, cmdCompleter] = this.generateAutoMainCommand(pluginInstance, cmd, tabs.get(command))
                 this.CommandManager.on(pluginInstance, command, {
-                    cmd: pluginInstance[cmd.executor].bind(pluginInstance),
-                    tab: tabs.has(command) ?
-                        pluginInstance[tabs.get(command).executor].bind(pluginInstance) :
-                        console.debug(`[${pluginInstance.description.name}] command ${cmd.name} is not registry tabCompleter`)
+                    cmd: cmdExecutor.bind(pluginInstance),
+                    tab: cmdCompleter?.bind(pluginInstance)
                 })
             }
         }
@@ -37,4 +37,29 @@ export class PluginCommandManager {
         let cmds = getPluginCommandMetadata(pluginInstance)
         cmds.forEach(cmd => this.CommandManager.off(pluginInstance, cmd.name))
     }
+
+    private generateAutoMainCommand(pluginInstance: plugin.Plugin, cmd: interfaces.CommandMetadata, tab: interfaces.CommandMetadata) {
+        let cmdExecutor = pluginInstance[cmd.executor]
+        let cmdCompleter = tab ? pluginInstance[tab.executor] : undefined
+        let cmdSubCache = Object.keys(pluginInstance.constructor.prototype).filter(s => s.startsWith('cmd')).map(s => s.substring(3))
+        if (cmd.autoMain) {
+            cmdExecutor = (sender: any, command: string, args: string[]) => {
+                let subcommand = args[0] || 'help'
+                let cmdKey = 'cmd' + subcommand
+                if (!pluginInstance[cmdKey]) {
+                    console.sender(sender, '§4未知的子命令: §c' + subcommand)
+                    pluginInstance['cmdhelp'] && console.sender(sender, `§6请执行 §b/${command} §ahelp §6查看帮助!`)
+                    return
+                }
+                args.shift()
+                return pluginInstance[cmdKey].apply(pluginInstance, [sender, ...args])
+            }
+            let originCompleter = cmdCompleter
+            cmdCompleter = (sender: any, command: string, args: string[]) => {
+                return (args.length == 1 ? cmdSubCache : []).concat(originCompleter?.apply(pluginInstance, [sender, command, args]) || [])
+            }
+        }
+        if (!cmdCompleter) { console.warn(`[${pluginInstance.description.name}] command ${cmd.name} is not registry tabCompleter`) }
+        return [cmdExecutor, cmdCompleter]
+    }
 }

packages/plugin/src/config.ts

@@ -92,6 +92,16 @@ export class PluginConfigManager {
             } else {
                 value = configLoader.load(base.read(metadata.file))
                 console.debug(`[${plugin.description.name}] Load Config ${metadata.variable} from file ${metadata.file} =>\n${JSON.stringify(value, undefined, 4)}`)
+                if (metadata.default) {
+                    let needSave = false
+                    for (const key of Object.keys(metadata.default)) {
+                        if (!value[key]) {
+                            value[key] = metadata.default[key]
+                            needSave = true
+                        }
+                    }
+                    needSave && base.save(metadata.file, configLoader.dump(value))
+                }
             }
             this.defienConfigProp(plugin, metadata, value)
         } catch (error) {

packages/plugin/src/interfaces.ts

@@ -47,6 +47,10 @@ export namespace interfaces {
          * 参数列表
          */
         paramtypes?: string[]
+        /**
+         * 自动化主命令
+         */
+        autoMain?: boolean
     }
     export interface ListenerMetadata extends ExecMetadata {
         /**
@@ -63,6 +67,10 @@ export namespace interfaces {
          * 配置文件版本号
          */
         version?: number
+        /**
+         * 默认配置
+         */
+        default?: any
         /**
          * 实体变量名称
          */

packages/plugin/src/manager.ts

@@ -81,9 +81,12 @@ export class PluginManagerImpl implements plugin.PluginManager {
         this.initialize()
         for (const [, scanner] of this.sacnnerMap) {
             try {
-                scanner.scan(folder).forEach(loadMetadata => {
+                console.i18n('ms.plugin.manager.scan', { scanner: scanner.type, folder })
+                let plugins = scanner.scan(folder)
+                console.i18n('ms.plugin.manager.scan.finish', { scanner: scanner.type, folder, size: plugins.length })
+                plugins.forEach(loadMetadata => {
                     try {
-                        this.loadPlugin(scanner.load(loadMetadata))
+                        this.loadAndRequirePlugin(loadMetadata)
                     } catch (error) {
                         console.error(`plugin scanner ${scanner.type} load ${loadMetadata.file} occurred error ${error}`)
                         console.ex(error)
@@ -158,6 +161,20 @@ export class PluginManagerImpl implements plugin.PluginManager {
         }
     }
 
+    private loadAndRequirePlugin(loadMetadata: plugin.PluginLoadMetadata) {
+        let startTime = Date.now()
+        let metadata = this.loadPlugin(loadMetadata.scanner.load(loadMetadata))
+        console.i18n('ms.plugin.manager.build', {
+            name: loadMetadata.metadata.name,
+            version: loadMetadata.metadata.version,
+            file: loadMetadata.file.toString().replace(root, ''),
+            scanner: loadMetadata.scanner.type,
+            loader: loadMetadata.loader.type,
+            cost: (Date.now() - startTime) / 1000
+        })
+        return metadata
+    }
+
     /**
      * 从文件加载插件
      * @param file java.io.File
@@ -165,7 +182,7 @@ export class PluginManagerImpl implements plugin.PluginManager {
     loadFromFile(file: string, scanner = this.sacnnerMap.get('file')): plugin.Plugin {
         if (!file) { throw new Error('plugin file can\'t be undefiend!') }
         if (!scanner) { throw new Error('plugin scanner can\'t be undefiend!') }
-        let metadata = this.loadPlugin(scanner.load(scanner.read(file)))
+        let metadata = this.loadAndRequirePlugin(scanner.read(file))
         let plugin = this.buildPlugin(metadata)
         this.load(plugin)
         this.enable(plugin)
@@ -233,21 +250,25 @@ export class PluginManagerImpl implements plugin.PluginManager {
     }
 
     private checkDepends(depends: string | string[]) {
-        if (!depends) return true
-        for (const depend of depends) { if (!this.metadataMap.has(depend)) return false }
-        return true
+        if (!depends) return []
+        let loseDepends = []
+        for (const depend of depends) { if (!this.metadataMap.has(depend)) loseDepends.push(depend) }
+        return loseDepends
     }
     private checkNativeDepends(depends: string | string[]) {
-        if (!depends) return true
-        for (const depend of depends) { if (!this.nativePluginManager.has(depend)) return false }
-        return true
+        if (!depends) return []
+        let loseDepends = []
+        for (const depend of depends) { if (!this.nativePluginManager.has(depend)) loseDepends.push(depend) }
+        return loseDepends
     }
     private buildPlugin(metadata: plugin.PluginMetadata) {
         if (this.instanceMap.has(metadata.name)) { throw new Error(`Plugin ${metadata.name} is already load from ${metadata.source}...`) }
         if (!this.loaderMap.has(metadata.type)) { throw new Error(`§4无法加载插件 §b${metadata.name} §4请检查 §c${metadata.type} §4加载器是否正常启用!`) }
         if (!this.serverChecker.check(metadata.servers)) { throw new Error(`§6插件 §b${metadata.name} §c服务器类型不兼容(${metadata.servers.join(',')}) §6忽略加载...`) }
-        if (!this.checkDepends(metadata.depends)) { throw new Error(`§4无法加载插件 §b${metadata.name} §4请检查依赖 §3${metadata.depends.join(',')} §4是否安装完整!`) }
-        if (!this.checkNativeDepends(metadata.nativeDepends)) { throw new Error(`§4无法加载插件 §b${metadata.name} §4请检查插件依赖 §3${metadata.nativeDepends.join(',')} §4是否安装完整!`) }
+        let loseDepends = this.checkDepends(metadata.depends) || []
+        if (loseDepends.length) { throw new Error(`§4无法加载插件 §b${metadata.name} §4请检查依赖 §3[${loseDepends.join(',')}] §4是否安装完整!`) }
+        let loseNativeDepends = this.checkNativeDepends(metadata.nativeDepends) || []
+        if (loseNativeDepends.length) { throw new Error(`§4无法加载插件 §b${metadata.name} §4请检查插件依赖 §3[${loseNativeDepends.join(',')}] §4是否安装完整!`) }
         let pluginInstance = this.loaderMap.get(metadata.type).build(metadata)
         if (!pluginInstance) { throw new Error(`§4加载器 §c${metadata.type} §4加载插件 §c${metadata.name} §4失败!`) }
         this.instanceMap.set(metadata.name, pluginInstance)

packages/plugin/src/scanner/file-scanner.ts

@@ -26,7 +26,6 @@ export class JSFileScanner implements plugin.PluginScanner {
 
     private scanFolder(folder: any): string[] {
         var files = []
-        console.i18n('ms.plugin.manager.scan', { folder })
         this.checkUpdateFolder(folder)
         // must check file is exist maybe is a illegal symbolic link file
         fs.list(folder).forEach((path: any) => {

packages/plugins/package.json

@@ -1,7 +1,7 @@
 {
     "private": true,
     "name": "@ccms/plugins",
-    "version": "0.10.1",
+    "version": "0.13.0",
     "description": "MiaoScript plugins package",
     "keywords": [
         "miaoscript",
@@ -26,13 +26,16 @@
         "@javatypes/spring-data-redis": "^0.0.3",
         "@javatypes/spring-web": "^0.0.3",
         "@javatypes/tomcat": "^0.0.3",
+        "@types/crypto-js": "^4.0.1",
         "reflect-metadata": "^0.1.13",
         "rimraf": "^3.0.2",
         "typescript": "^4.0.5"
     },
     "dependencies": {
-        "@ccms/api": "^0.10.1",
-        "@ccms/container": "^0.10.1",
-        "@ccms/plugin": "^0.10.1"
+        "@babel/standalone": "^7.12.9",
+        "@ccms/api": "^0.13.0",
+        "@ccms/container": "^0.13.0",
+        "@ccms/plugin": "^0.13.0",
+        "crypto-js": "^4.0.0"
     }
 }

packages/plugins/src/HelloWorld.ts

@@ -1,24 +1,24 @@
 /// <reference types="@javatypes/bungee-api" />
-/// <reference types="@javatypes/spigot-api" />
+/// <reference types="@javatypes/bukkit-api" />
 /// <reference types="@javatypes/sponge-api" />
 
-import { server } from '@ccms/api';
-import { inject } from '@ccms/container';
-import { plugin, interfaces, cmd, listener, tab } from '@ccms/plugin'
+import { server } from '@ccms/api'
+import { Autowired } from '@ccms/container'
+import { Cmd, JSPlugin, Listener, Tab, interfaces } from '@ccms/plugin'
 
-@plugin({ name: 'HelloWorld', version: '1.0.0', author: 'MiaoWoo', source: __filename })
+@JSPlugin({ name: 'HelloWorld', version: '1.0.0', author: 'MiaoWoo', source: __filename })
 export class HelloWorld extends interfaces.Plugin {
-    @inject(server.Server)
+    @Autowired(server.Server)
     private Server: server.Server
 
     load() {
-        this.logger.log('Plugin load from MiaoScript Plugin System...');
+        this.logger.log('Plugin load from MiaoScript Plugin System...')
     }
     enable() {
-        this.logger.log('Plugin enable from MiaoScript Plugin System...');
+        this.logger.log('Plugin enable from MiaoScript Plugin System...')
     }
     disable() {
-        this.logger.log('Plugin disable from MiaoScript Plugin System...');
+        this.logger.log('Plugin disable from MiaoScript Plugin System...')
     }
 
     bukkitload() {
@@ -61,28 +61,29 @@ export class HelloWorld extends interfaces.Plugin {
         this.logger.log('Plugin Disable When ServerType is Nukkit!')
     }
 
-    @cmd()
+    @Cmd()
     hello(sender: any, command: string, args: string[]) {
-        this.logger.log(sender, command, args);
+        this.logger.log(sender, command, args)
         sender.sendMessage(JSON.stringify({ command, ...args }))
     }
 
-    @tab()
+    @Tab()
     tabhello(_sender: any, _command: string, _args: string[]) {
         return ['world']
     }
 
-    @listener({ servers: ['bukkit', 'nukkit'] })
+    @Listener({ servers: ['bukkit', 'nukkit'] })
     PlayerJoin(event: org.bukkit.event.player.PlayerJoinEvent) {
-        let plyaer = event.getPlayer();
+        let plyaer = event.getPlayer()
         this.logger.console(`§cBukkit §aPlayerJoinEvent: §b${plyaer.getName()}`)
-        setTimeout(() => this.sendWelcome(plyaer), 10);
+        setTimeout(() => this.sendWelcome(plyaer), 500)
     }
 
-    @listener({ servers: ['sponge'] })
+    @Listener({ servers: ['sponge'] })
     ClientConnectionEvent$Join(event: org.spongepowered.api.event.network.ClientConnectionEvent.Join) {
+        event.getTargetEntity().getLocation()
         this.logger.console(`§cSponge §aClientConnectionEvent.Join: §b${event.getTargetEntity().getName()}`)
-        setTimeout(() => this.sendWelcome(event.getTargetEntity()), 10);
+        setTimeout(() => this.sendWelcome(event.getTargetEntity()), 500)
     }
 
     private sendWelcome(player: any) {
@@ -90,10 +91,9 @@ export class HelloWorld extends interfaces.Plugin {
         this.logger.sender(player, `§6当前版本: §c${this.Server.getVersion()}`)
     }
 
-    @listener({ servers: ['bungee'] })
-    ServerConnected(e: any) {
-        let event = e as net.md_5.bungee.api.event.ServerConnectedEvent
+    @Listener({ servers: ['bungee'] })
+    ServerConnected(event: net.md_5.bungee.api.event.ServerConnectedEvent) {
         this.logger.console(`§cBungeeCord §aServerConnectedEvent: §b${event.getPlayer().getDisplayName()}`)
-        setTimeout(() => this.logger.sender(event.getPlayer(), `§a欢迎来到 §bMiaoScript §a的世界 §6来自 §cBungeeCord §6的问候!`), 10);
+        setTimeout(() => this.logger.sender(event.getPlayer(), `§a欢迎来到 §bMiaoScript §a的世界 §6来自 §cBungeeCord §6的问候!`), 500)
     }
 }

packages/plugins/src/MiaoAuth.ts

@@ -0,0 +1,48 @@
+/// <reference types="@javatypes/bungee-api" />
+/// <reference types="@javatypes/bukkit-api" />
+/// <reference types="@javatypes/sponge-api" />
+
+import { plugin, server } from '@ccms/api'
+import { Autowired } from '@ccms/container'
+import { Cmd, interfaces, JSPlugin, Tab } from '@ccms/plugin'
+
+import type { MiaoReward } from './MiaoReward'
+import * as fs from '@ccms/common/dist/fs'
+
+@JSPlugin({ version: '1.0.0', author: 'MiaoWoo', source: __filename, depends: ['MiaoReward'] })
+export class MiaoAuth extends interfaces.Plugin {
+    @Autowired()
+    private Server: server.Server
+    @Autowired()
+    private pluginManager: plugin.PluginManager
+
+    private MiaoReward: MiaoReward
+
+    load() {
+    }
+
+    enable() {
+        this.MiaoReward = this.pluginManager.getPlugin('MiaoReward') as MiaoReward
+        if (!this.MiaoReward) { return this.logger.error('当前脚本插件需要 MiaoReward 作为前置插件!') }
+
+    }
+
+    disable() {
+    }
+
+    @Cmd({ autoMain: true })
+    msma() { }
+
+    cmdbind(sender: org.bukkit.entity.Player) {
+        if (!sender.getItemInHand) { return this.logger.sender(sender, '§4控制台无法执行此命令!') }
+        if (!this.MiaoReward.serverInfo) { return this.logger.sender(sender, '§4当前服务器尚未配置 请联系管理员配置MiaoReward!') }
+        this.MiaoReward.scanAuth(sender, 'bind', { title: '账号绑定', content: '是否绑定' }, (token, user) => {
+
+        }, () => {
+
+        })
+    }
+
+    @Tab()
+    tabmsma() { }
+}

packages/plugins/src/MiaoChat.ts

@@ -50,7 +50,7 @@ class MiaoMessage {
     }
 }
 
-@plugin({ name: 'MiaoChat', version: '1.0.0', author: 'MiaoWoo', source: __filename })
+@plugin({ version: '1.0.1', author: 'MiaoWoo', source: __filename })
 export class MiaoChat extends interfaces.Plugin {
     @Autowired()
     private Server: server.Server

packages/plugins/src/MiaoConsole.ts

@@ -19,7 +19,7 @@ let help = [
     '§6/mconsole §areload               §6-  §3重载插件',
 ]
 
-@plugin({ prefix: 'Console', version: '1.0.0', author: 'MiaoWoo', servers: ['!nukkit'], source: __filename })
+@plugin({ prefix: 'Console', version: '1.1.0', author: 'MiaoWoo', servers: ['!nukkit'], source: __filename })
 export class MiaoConsole extends interfaces.Plugin {
     @Autowired(ContainerInstance)
     private container: Container
@@ -42,6 +42,7 @@ export class MiaoConsole extends interfaces.Plugin {
     private rootLogger: any
     private appender: any
     private handler: any
+    private babel: any
 
     private logCache: string[] = []
 
@@ -62,6 +63,15 @@ export class MiaoConsole extends interfaces.Plugin {
                 this.logCache = this.logCache.slice(this.logCache.length - 30, this.logCache.length)
             }
         })
+        this.task.create(() => {
+            if (!this.babel) {
+                this.logger.console('§3脚本 Babel 引擎初始化中 请稍候...')
+                let startTime = Date.now()
+                this.babel = require('@babel/standalone')
+                this.compileCode(`() => console.log("Babel ready!")`)
+                this.logger.console(`§3脚本 Babel 引擎初始化完毕 耗时 §a${Date.now() - startTime}ms...`)
+            }
+        }).async().submit()
     }
 
     @cmd()
@@ -81,8 +91,6 @@ export class MiaoConsole extends interfaces.Plugin {
     }
 
     cmdreload(sender: any) {
-        // @ts-ignore
-        require.clear('websocket')
         this.pluginManager.reload(this)
         return
     }
@@ -223,7 +231,7 @@ export class MiaoConsole extends interfaces.Plugin {
     startSocketIOServer() {
         let namespace = this.socketIOServer.of('/MiaoConsole')
         process.on('message', (msg) => namespace.emit('log', msg))
-        namespace.on('connect', (client: SocketIOSocket) => {
+        namespace.on('connection', (client: SocketIOSocket) => {
             if (!this.token) {
                 this.logger.console(`§6客户端 §b${client.id} §a请求连接 §4服务器尚未设置 Token 无法连接!`)
                 client.emit('unauthorized', () => client.disconnect(true))
@@ -247,14 +255,23 @@ export class MiaoConsole extends interfaces.Plugin {
             client.emit('log', `Currect Server Version is ${this.server.getVersion()}`)
         })
         client.on('command', (cmd) => {
-            setTimeout(() => this.server.dispatchConsoleCommand(cmd), 0)
+            this.task.callSyncMethod(() => this.server.dispatchConsoleCommand(cmd))
             client.emit('log', `§6命令: §b${cmd} §a执行成功!`)
         })
         client.on('tabComplate', (input, index, callback) => {
-            callback?.(this.command.tabComplete(this.server.getConsoleSender(), input, index) || [])
+            try {
+                callback?.(this.command.tabComplete(this.server.getConsoleSender(), input, index) || [])
+            } catch (error) {
+                callback?.([])
+                client.emit('log', `§4命令补全发生异常: ${error}!`)
+                console.ex(error)
+            }
         })
         client.on('exec', (code) => {
             try {
+                if (!this.babel) {
+                    return client.emit('log', '§cBabel 引擎初始化中 请稍候再试!')
+                }
                 client.emit('log', this.runCode(code, client.nsp, client))
             } catch (ex) {
                 client.emit('log', `§4代码执行异常 错误: ${ex}\n${console.stack(ex).join('\n')}`)
@@ -307,15 +324,30 @@ export class MiaoConsole extends interfaces.Plugin {
             this.container,
             this.pluginManager
         ]
-        let tfunc = new Function(
-            ...paramNames,
-            `var api = require('@ccms/api');
+        client.emit('log', '§3代码编译中 请稍候...')
+        let startTime = Date.now()
+        let tfunc = new Function(...paramNames, this.compileCode(code))
+        client.emit('log', `§3代码编译完成 耗时 §e${Date.now() - startTime}ms §b开始执行 请稍候...`)
+        return tfunc.apply(this, params) + ''
+    }
+
+    private compileCode(code: string) {
+        return `var api = require('@ccms/api');
 if (this.serverType == "spring") {
     var dbm = container.get(api.database.DataBaseManager)
     var db = dbm.getMainDatabase()
     var bf = base.getInstance().getAutowireCapableBeanFactory()
 }
-return '§a返回结果: §r'+ eval(${JSON.stringify(code)});`)
-        return this.task.callSyncMethod(() => tfunc.apply(this, params)) + ''
+var startTime = Date.now()
+var result = eval(${JSON.stringify(this.babel.transform(code, {
+            filename: 'miaoconsole-temp.ts',
+            presets: ['typescript', 'es2015'],
+            plugins: [
+                ['proposal-decorators', { legacy: true }],
+                'transform-runtime'
+            ],
+            sourceMaps: "inline"
+        }).code)});
+return '§3代码执行完成 耗时 §e' + (Date.now() - startTime) + 'ms §a返回结果: §r'+ result`
     }
 }

packages/plugins/src/MiaoExplorer.ts

@@ -46,7 +46,7 @@ export class MiaoExplorer extends interfaces.Plugin {
         let consolePlugin: any = this.pluginManager.getPlugin('MiaoConsole')
         this.token = consolePlugin.token
         this.namespace = server.of('/MiaoExplorer')
-        this.namespace.on('connect', (client: SocketIOSocket) => {
+        this.namespace.on('connection', (client: SocketIOSocket) => {
             if (!this.token) {
                 this.logger.console(`§6客户端 §b${client.id} §a请求连接 §4服务器尚未设置 Token 无法连接!`)
                 client.emit('unauthorized', () => client.disconnect(true))

packages/plugins/src/MiaoParticle.ts

@@ -0,0 +1,36 @@
+/// <reference types="@javatypes/bungee-api" />
+/// <reference types="@javatypes/bukkit-api" />
+/// <reference types="@javatypes/sponge-api" />
+
+import { particle } from '@ccms/api'
+import { Autowired } from '@ccms/container'
+import { Cmd, JSPlugin, Tab, interfaces } from '@ccms/plugin'
+
+@JSPlugin({ version: '1.0.0', author: 'MiaoWoo', source: __filename })
+export class MiaoParticle extends interfaces.Plugin {
+    @Autowired()
+    private particleManager: particle.ParticleManager
+
+    private particleTask: particle.ParticleTask
+
+    enable() {
+        // let boot = new Bootstrap()
+        this.particleTask = this.particleManager.create(new particle.Circle(2, 20).setParticle(org.bukkit.Particle.BLOCK_DUST), this)
+    }
+
+    diable() {
+        this.particleTask.cancel()
+    }
+
+    @Cmd({ autoMain: true })
+    mpt() { }
+
+    cmdtest(sender: org.bukkit.entity.Player) {
+        this.particleTask.follow(sender).async(true).timer(5).submit()
+    }
+
+    @Tab()
+    tabmpt(_sender: any, _command: string, _args: string[]) {
+        return []
+    }
+}

packages/plugins/src/MiaoPay.ts

@@ -0,0 +1,295 @@
+/// <reference types="@javatypes/bungee-api" />
+/// <reference types="@javatypes/bukkit-api" />
+/// <reference types="@javatypes/sponge-api" />
+
+import { plugin, server, task } from '@ccms/api'
+import { Autowired, JSClass } from '@ccms/container'
+import { Cmd, Config, interfaces, JSPlugin, PluginConfig, Tab } from '@ccms/plugin'
+
+import type { MiaoReward } from './MiaoReward'
+import http from '@ccms/common/dist/http'
+import * as CryptoJS from "crypto-js"
+
+interface PlayerPointsAPI {
+    look(name: string)
+    give(name: string, amount: number)
+    take(name: string, amount: number)
+}
+
+interface Order {
+    order_id: string
+    amount: string
+    url: string
+}
+interface Sync {
+    scaned: boolean
+    start?: number
+    left?: number
+    cancelled?: boolean
+}
+
+interface PlaceholderAPI {
+    registerPlaceholderHook: (key: string, onPlaceholderRequest: (player, s) => string) => void
+    unregisterPlaceholderHook: (key: string) => void
+    setPlaceholders: (player: any, str: string) => string
+}
+
+const defaultConfig = {
+    prefix: '§6[§b喵式支付§6]',
+    id: '',
+    secret: '',
+    command: 'p give %player_name% %amount%',
+    check: '%playerpoints_points%',
+    ratio: 100,
+    coinName: '点券'
+}
+
+@JSPlugin({ version: '1.2.0', author: 'MiaoWoo', source: __filename, depends: ['MiaoReward'], nativeDepends: ['PlaceholderAPI'] })
+export class MiaoPay extends interfaces.Plugin {
+    @Autowired()
+    private server: server.Server
+    @Autowired()
+    private taskManager: task.TaskManager
+    @Autowired()
+    private pluginManager: plugin.PluginManager
+
+    @JSClass('me.clip.placeholderapi.PlaceholderAPI')
+    private PlaceholderAPI: PlaceholderAPI
+
+    private MiaoReward: MiaoReward
+
+    private cacheMap = new Map<string, Order>();
+    private cacheSyncMap = new Map<string, Sync>();
+
+    @Config()
+    private config: PluginConfig & typeof defaultConfig = defaultConfig
+
+    load() {
+        let needSave = false
+        for (const key of Object.keys(defaultConfig)) {
+            if (!this.config[key]) {
+                this.config[key] = defaultConfig[key]
+                needSave = true
+            }
+        }
+        needSave && this.config.save()
+    }
+
+    cmdtest(sender: org.bukkit.entity.Player) {
+        try {
+            this.logger.sender(sender, this.getPlayerAmount(sender))
+        } catch (error) {
+            return this.logger.sender(sender, error.message)
+        }
+    }
+
+    enable() {
+        this.MiaoReward = this.pluginManager.getPlugin('MiaoReward') as MiaoReward
+        if (!this.MiaoReward) { return this.logger.error('当前脚本插件需要 MiaoReward 作为前置脚本插件!') }
+        if (!this.config.id || !this.config.secret) { return this.logger.console('§4尚未配置商户信息 将无法正常收款!') }
+    }
+
+    disable() {
+        this.cacheMap.forEach((v, k) => {
+            this.MiaoReward.cancelTask(this.server.getPlayer(k))
+        })
+        this.cacheMap.clear()
+    }
+
+    @Cmd({ autoMain: true })
+    mpay() { }
+
+    cmdpay(sender: org.bukkit.entity.Player, amount: number) {
+        if (!sender.getItemInHand) { return this.logger.sender(sender, '§4控制台无法执行此命令!') }
+        if (!this.MiaoReward.serverInfo) { return this.logger.sender(sender, '§4当前服务器尚未配置 请联系管理员先配置MiaoReward!') }
+        if (!this.config.id || !this.config.secret) { return this.logger.sender(sender, '§c当前服务器尚未配置 请联系管理员配置支付密钥!') }
+        if (this.cacheMap.has(sender.getName())) {
+            this.logger.sender(sender, '§c您有一笔订单尚未完成 请完成支付或等待订单超时!')
+            let sync = this.cacheSyncMap.get(sender.getName())
+            if (!sync.cancelled) { return }
+            sync.left = 55 - (Math.round(Date.now() / 1000) - sync.start)
+            let order = this.cacheMap.get(sender.getName())
+            this.MiaoReward.setItemAndTp(sender, order.url, sync, `充值 ${order.amount} ${this.config.coinName}`, `支付宝/微信/QQ 扫码支付`)
+            return
+        }
+        if (amount < 1) { return this.logger.sender(sender, `§c充值异常 §4充值金额不得小于 1 ${this.config.coinName}!`) }
+        try {
+            this.getPlayerAmount(sender)
+        } catch (error) {
+            return this.logger.sender(sender, error.message)
+        }
+        this.MiaoReward.sendTitle(sender, `§6充值 §a${amount} §6${this.config.coinName}`, '§c正在请求充值二维码 请稍候...')
+        let sync = { scaned: false, start: Math.round(Date.now() / 1000) }
+        let order = this.createOrder(sender, amount)
+        this.cacheMap.set(sender.getName(), order)
+        this.cacheSyncMap.set(sender.getName(), sync)
+        let order_id = order.order_id
+        this.MiaoReward.setItemAndTp(sender, order.url, sync, `充值 ${amount} ${this.config.coinName}`, `支付宝/微信/QQ 扫码支付`)
+        this.taskManager.create(() => {
+            try {
+                let status = this.queryStatus(order_id, 0, 55)
+                if (status.code != 200) { throw new Error('§c扫码超时 请重新充值!') }
+                this.MiaoReward.sendTitle(sender, '§a已扫码', `§3订单已创建 请及时支付!`)
+                this.MiaoReward.sendActionBar(sender, '§6订单号: §3' + order_id)
+                sync.scaned = true
+                status = this.queryStatus(order_id, 1, 120)
+                if (status.code != 200) { throw new Error('§c支付超时 请重新充值!') }
+                if (status.data == 2) {
+                    this.MiaoReward.sendTitle(sender, '§a已支付', `§3订单已支付 请等待充值到账...`)
+                    this.MiaoReward.sendActionBar(sender, '§6订单号: §3' + order_id)
+                    this.logger.sender(sender, `§6订单号: §3${order_id} §a支付成功!`)
+                    this.recharge(sender, order_id, order.amount)
+                } else {
+                    this.logger.sender(sender, `§c充值系统异常 §4订单状态异常${status.data} §c点券可能未到账 请联系管理员!`)
+                }
+            } catch (error) {
+                let cacheOrder = this.cacheMap.get(sender.getName())
+                if (cacheOrder && cacheOrder.order_id == order_id) {
+                    this.MiaoReward.sendTitle(sender, '§4充值失败', error.message)
+                }
+            } finally {
+                sync.scaned = true
+                this.cacheMap.delete(sender.getName())
+                this.cacheSyncMap.delete(sender.getName())
+            }
+        }).async().submit()
+        this.MiaoReward.clearTitle(sender)
+    }
+
+    cmdquery(sender: org.bukkit.entity.Player, id: string) {
+        if (!id) { return this.logger.sender(sender, '§c请输入订单号!') }
+        this.taskManager.create(() => {
+            let result = this.queryOrder(id, sender.getName(), sender.getUniqueId().toString())
+            if (result.code != 200) { return this.logger.sender(sender, `§c查询异常! §4ERROR: ${result.msg}`) }
+            let order = result.data
+            this.logger.sender(sender, [
+                `§6商户名称: §3${order.appname}`,
+                `§6订单号: §3${id}`,
+                `§6商品: §b${order.subject}`,
+                `§6金额: §e${order.amount}`,
+                `§6玩家: §a${order.username}`,
+                `§6状态: §c${order.status}`,
+            ])
+            if (order.status > 1 && order.status < 4) {
+                this.logger.sender(sender, `§3当前订单已支付 尚未完成充值 开始补单操作...`)
+                this.recharge(sender, id, order.amount)
+            }
+        }).async().submit()
+    }
+
+    /**
+     * @param amount 订单金额(非点券金额)
+     */
+    recharge(sender: org.bukkit.entity.Player, order_id: string, amount: number) {
+        let point = amount * this.config.ratio
+        this.taskManager.create(() => {
+            let finish = this.preFinishOrder(order_id)
+            if (finish.code != 200) {
+                return this.logger.console(`§c充值系统异常 订单 §3${order_id} 预标记异常! §4${this.config.coinName}已停止充值 §c请手动补单!`)
+            }
+            this.taskManager.callSyncMethod(() => {
+                let prePoint = this.getPlayerAmount(sender)
+                let command = this.config.command.replace('%player_name%', sender.getName()).replace('%amount%', `${point}`).replace('%remark%', `${order_id}`)
+                if (!this.server.dispatchConsoleCommand(command)) {
+                    return this.sendError(sender, order_id, amount, '§4充值命令执行异常!')
+                }
+                let nowPoint = this.getPlayerAmount(sender)
+                if (nowPoint != prePoint + point) {
+                    return this.sendError(sender, order_id, amount, '§4充值结果检测异常!')
+                } else {
+                    this.taskManager.create(() => {
+                        this.logger.sender(sender, [
+                            `§6充值 §a${point} §6${this.config.coinName} §a成功 §6当前账户余额: §3${nowPoint} §6${this.config.coinName}`,
+                            `§c如出现未到账的情况 请联系管理员!`
+                        ])
+                        let finish = this.finishOrder(order_id)
+                        if (finish.code != 200) {
+                            return this.logger.console(`§c充值系统异常 订单 §3${order_id} 完成标记异常! §4${this.config.coinName}可能重复到账!`)
+                        }
+                    }).async().submit()
+                }
+            })
+        }).async().submit()
+    }
+
+    sendError(sender: org.bukkit.entity.Player, order_id: string, amount: number, error: string) {
+        return this.logger.sender(sender, [
+            `§c========== ${this.config.prefix}§4充值异常 §c==========`,
+            `§6异常订单: §3${order_id}`,
+            `§6订单金额: §3${amount}`,
+            `§6异常原因: §4${error}`,
+            `§6异常账号: §b${sender.getName()}`,
+            `§6异常时间: §a${new Date().toLocaleDateString()} ${new Date().toLocaleTimeString()}`,
+            `§c如果已付款但${this.config.coinName}未到账 请截图发往QQ群!`,
+            `§c========== ${this.config.prefix}§4充值异常 §c==========`,
+        ])
+    }
+
+    @Tab()
+    tabmpay() { }
+
+    private getPlayerAmount(sender: any): number {
+        let result = this.PlaceholderAPI.setPlaceholders(sender, this.config.check)
+        let amount = parseFloat(result)
+        if (isNaN(amount)) {
+            throw new Error(`§c读取玩家 §3${this.config.coinName} §c异常 §6请检查 §3check §6配置是否正确!\n§6数据解析链路: §3${this.config.check} §6=> §3${result} §6=> §3${amount}`)
+        }
+        return amount
+    }
+
+    private queryStatus(id: string, wait: number, time = 60) {
+        return this.httpPost('/status', { id, wait, time })
+    }
+
+    private preFinishOrder(id: string) {
+        return this.httpPost('/preFinish', { id })
+    }
+
+    private finishOrder(id: string) {
+        return this.httpPost('/finish', { id })
+    }
+
+    private createOrder(sender: org.bukkit.entity.Player, amount: number) {
+        let result = this.httpPost('/create', {
+            subject: `${this.MiaoReward.serverInfo.name} 充值 ${amount} ${this.config.coinName}`,
+            totalAmount: amount / this.config.ratio,
+            username: sender.getName(),
+            union_id: sender.getUniqueId().toString()
+        })
+        if (result.code != 200) {
+            throw new Error(`订单创建失败: ${result.msg}`)
+        }
+        return result.data
+    }
+
+    private queryOrder(id: string, username: string, uuid: string) {
+        return this.httpPost('/query', { id, username, uuid })
+    }
+
+    private httpPost(method: string, data: any) {
+        let startTime = Date.now()
+        data.appid = this.config.id
+        data.timestamp = Math.round(Date.now() / 1000)
+        data.sign = this.sign(data)
+        let url = `https://pay.yumc.pw/api${method}`
+        let result = http.post(url, data)
+        console.debug(`
+====== HTTP POST ======
+REQUEST URL : ${url}
+REQUEST DATA: ${JSON.stringify(data)}
+RESPONSE    : ${JSON.stringify(result)}
+CAST TIME   : ${Date.now() - startTime}`)
+        return result
+    }
+
+    private http_build_query(params: any) {
+        return Object.keys(params).filter(key => key !== 'sign' && params[key] != undefined && params[key] != null)
+            .sort().map(key => key + '=' + params[key]).join('&')
+    }
+
+    private sign(params) {
+        // 排序后转换为字符串
+        let signStr = `${this.http_build_query(params)}&key=${this.config.secret}`
+        return CryptoJS.MD5(signStr).toString().toUpperCase()
+    }
+}

packages/plugins/src/MiaoReward.ts

@@ -21,6 +21,26 @@ interface UserInfo {
     sign: string
     video: string
     box: string
+    block: string
+}
+
+interface ServerInfo {
+    // 16,
+    id: number
+    // "圈云大陆",
+    name: string
+    // 1,
+    owner: number
+    // 48200,
+    score: number
+    // 1,
+    ratio: number
+    // 1,
+    audit: number
+    // 2,
+    status: number
+    // 0
+    today: number
 }
 
 let createPacketAdapterFunction = eval(`
@@ -30,9 +50,18 @@ function(cls, plugin, type, onPacketSending){
     }
 }`)
 
-@JSPlugin({ prefix: 'MRD', version: '1.4.2', author: 'MiaoWoo', servers: [constants.ServerType.Bukkit], source: __filename })
+const defaultConfig = {
+    prefix: '§6[§b广告系统§6]§r',
+    serverId: '',
+    serverToken: '',
+    drawCommand: 'p give %player_name% %amount%',
+    coinName: '点券',
+    joinTip: true
+}
+
+@JSPlugin({ prefix: 'MRD', version: '1.5.1', author: 'MiaoWoo', servers: [constants.ServerType.Bukkit], nativeDepends: ['ProtocolLib', 'PlaceholderAPI'], source: __filename })
 export class MiaoReward extends interfaces.Plugin {
-    private serverInfo: any
+    public serverInfo: ServerInfo
     private cacheBindUuid = ''
     private zeroMapView = undefined
     private playerImageCache = new Map<string, any>()
@@ -53,19 +82,7 @@ export class MiaoReward extends interfaces.Plugin {
     private bungee: proxy.BungeeCord
 
     @Config()
-    private config: PluginConfig & {
-        prefix: string
-        serverId: string
-        serverToken: string
-        drawCommand: string
-        coinName: string
-    } = {
-            prefix: '§6[§b广告系统§6]§r',
-            serverId: '',
-            serverToken: '',
-            drawCommand: 'p give %player_name% %amount%',
-            coinName: '点券'
-        }
+    private config: PluginConfig & typeof defaultConfig = defaultConfig
 
     @JSClass('org.bukkit.Bukkit')
     private Bukkit: any
@@ -95,6 +112,10 @@ export class MiaoReward extends interfaces.Plugin {
             this.config.coinName = '点券'
             this.config.save()
         }
+        if (!this.config.joinTip) {
+            this.config.joinTip = true
+            this.config.save()
+        }
         //@ts-ignore
         this.logger.prefix = this.config.prefix
         this.downgrade = this.Bukkit.server.class.name.split('.')[3] == "v1_7_R4"
@@ -172,13 +193,15 @@ export class MiaoReward extends interfaces.Plugin {
         } else {
             this.PlaceholderAPI.registerPlaceholderHook("mrd", new this.PlaceholderHook({
                 onPlaceholderRequest: (player: any, s: string) => {
-                    if (!this.playerInfoCache.has(player.getName())) { return '用户未绑定' }
+                    if (!this.playerInfoCache.has(player.getName())) { return '数据加载中' }
                     let data = this.playerInfoCache.get(player.getName())
+                    if (!data) { return '用户未绑定' }
                     switch (s.toLowerCase()) {
                         case "balance": return data.balance
                         case "sign": return data.sign
                         case "video": return data.video
                         case "box": return data.box
+                        case "block": return data.block
                         default: return "未知的参数: " + s
                     }
                 }
@@ -197,11 +220,14 @@ export class MiaoReward extends interfaces.Plugin {
         this.initPacketAdapter()
     }
 
-    createPacketAdapter(onPacketSending: (event) => void) {
+    private createPacketAdapter(onPacketSending: (event) => void) {
         return createPacketAdapterFunction(this.PacketAdapter, base.getInstance(), [this.PacketType.Play.Server.MAP], onPacketSending)
     }
 
-    initPacketAdapter() {
+    private initPacketAdapter() {
+        if (!this.ProtocolLibrary) {
+            return this.logger.console(`§4服务器未安装 ProtocolLib 无法扫码功能 请安装后重试!`)
+        }
         this.adapter = this.createPacketAdapter((event) => {
             let integers = event.getPacket().getIntegers().getValues()
             let mapId = integers.get(0)
@@ -247,6 +273,7 @@ export class MiaoReward extends interfaces.Plugin {
     }
 
     disable() {
+        if (!this.ProtocolLibrary) return
         this.PlaceholderAPI?.unregisterPlaceholderHook("mrd")
         this.adapter && this.ProtocolLibrary.getProtocolManager().removePacketListener(this.adapter)
         Java.from(this.server.getOnlinePlayers()).forEach(p => this.checkAndClear(p))
@@ -254,7 +281,7 @@ export class MiaoReward extends interfaces.Plugin {
     }
 
     @Cmd()
-    mrd(sender: any, command: string, args: string[]) {
+    private mrd(sender: any, command: string, args: string[]) {
         let cmd = args[0] || 'help'
         let cmdKey = 'cmd' + cmd
         if (!this[cmdKey]) {
@@ -266,7 +293,7 @@ export class MiaoReward extends interfaces.Plugin {
         this.taskManager.create(() => this[cmdKey](sender, ...args)).async().submit()
     }
 
-    private scanAuth(sender: org.bukkit.entity.Player, scanType: string, scanObj: { title: string, content: string }, success: (token: string, user: any) => void, cancel?: () => void) {
+    public scanAuth(sender: org.bukkit.entity.Player, scanType: string, scanObj: { title: string, content: string }, success: (token: string, user: any) => void, cancel?: () => void) {
         this.logger.sender(sender, '§a正在获取授权二维码...')
         let scan = this.httpPost('https://reward.yumc.pw/auth/scan', { ...scanObj, type: scanType })
         if (scan.code == 200) {
@@ -313,6 +340,9 @@ export class MiaoReward extends interfaces.Plugin {
     }
 
     private bindCheck(sender: org.bukkit.entity.Player) {
+        if (!this.ProtocolLibrary) {
+            return this.logger.sender(sender, `§4服务器未安装 ProtocolLib 无法扫码功能 请安装后重试!`)
+        }
         let scanning = this.playerTaskCache.has(sender.getName())
         if (scanning) {
             this.logger.sender(sender, "§4当前正在进行扫码 请稍候重试!")
@@ -320,7 +350,7 @@ export class MiaoReward extends interfaces.Plugin {
         return scanning
     }
 
-    cmdopen(sender: org.bukkit.entity.Player) {
+    private cmdopen(sender: org.bukkit.entity.Player) {
         if (this.bindCheck(sender)) return
         this.logger.sender(sender, '§a正在获取小程序二维码...')
         let sync = { scaned: false }
@@ -328,7 +358,7 @@ export class MiaoReward extends interfaces.Plugin {
         this.taskManager.create(() => sync.scaned = true).later(20 * 50).submit()
     }
 
-    cmdbind(sender: org.bukkit.entity.Player, server: boolean) {
+    private cmdbind(sender: org.bukkit.entity.Player, server: boolean) {
         if (!sender.getItemInHand) { return this.logger.sender(sender, '§c手持物品检测异常 请检查是否在客户端执行命令!') }
         if (this.bindCheck(sender)) return
         if (server) {
@@ -338,9 +368,9 @@ export class MiaoReward extends interfaces.Plugin {
         }
     }
 
-    cmddraw(sender: org.bukkit.entity.Player, amount: number) {
+    private cmddraw(sender: org.bukkit.entity.Player, amount: number) {
         if (!sender.getItemInHand) { return this.logger.sender(sender, '§c手持物品检测异常 请检查是否在客户端执行命令!') }
-        if (!this.playerInfoCache.has(sender.getName())) { return this.logger.sender(sender, '§c当前用户尚未绑定服务器玩家账号 请先执行 /mrd bind 绑定账号!') }
+        if (!this.playerInfoCache.get(sender.getName())) { return this.logger.sender(sender, '§c当前用户尚未绑定服务器玩家账号 请先执行 /mrd bind 绑定账号!') }
         amount = Number(amount)
         if (!Number.isInteger(amount)) {
             return this.logger.sender(sender, '§4金额必须是数字!')
@@ -356,7 +386,7 @@ export class MiaoReward extends interfaces.Plugin {
                 "是否授权 " + this.serverInfo.name + " 兑换喵币",
                 "兑换玩家: " + sender.getName(),
                 "兑换数量: " + amount,
-                "兑换比例: " + parseFloat(this.serverInfo.ratio),
+                "兑换比例: " + this.serverInfo.ratio,
                 "预计到帐: " + (amount * this.serverInfo.ratio).toFixed(0),
                 "注意: 数据可能更新不及时 请以实际到账金额为准!"
             ].join('\n')
@@ -404,7 +434,7 @@ export class MiaoReward extends interfaces.Plugin {
         ])
     }
 
-    cmdrank(sender: any, boardcast: boolean) {
+    private cmdrank(sender: any, boardcast: boolean) {
         if (!sender.isOp()) { return this.logger.sender(sender, '§4你没有此命令的权限!') }
         let result = this.httpPost(`https://reward.yumc.pw/server/rank`, {
             id: this.config.serverId,
@@ -425,7 +455,7 @@ export class MiaoReward extends interfaces.Plugin {
         }
     }
 
-    cmdserver(sender: any) {
+    private cmdserver(sender: any) {
         if (!sender.isOp()) { return this.logger.sender(sender, '§4你没有此命令的权限!') }
         let result = this.httpPost(`https://reward.yumc.pw/server/server`, {
             id: this.config.serverId,
@@ -445,7 +475,7 @@ export class MiaoReward extends interfaces.Plugin {
         ])
     }
 
-    cmdratio(sender: any, ratioStr: string, confirm: string) {
+    private cmdratio(sender: any, ratioStr: string, confirm: string) {
         if (!sender.isOp()) { return this.logger.sender(sender, '§4你没有此命令的权限!') }
         if (!sender.getItemInHand) { return this.logger.sender(sender, '§c手持物品检测异常 请检查是否在客户端执行命令!') }
         let [ratio, mbr, msg] = this.ratio2string(ratioStr)
@@ -484,7 +514,7 @@ export class MiaoReward extends interfaces.Plugin {
         })
     }
 
-    cmdreload() {
+    private cmdreload() {
         this.config.reload()
     }
 
@@ -556,35 +586,41 @@ export class MiaoReward extends interfaces.Plugin {
         this.setItemAndTp(sender, bindUrl, sync)
     }
 
-    private sendActionBar(sender, message) {
+    public sendActionBar(sender, message) {
         if (!this.downgrade) {
             this.chat.sendActionBar(sender, message)
         }
     }
 
-    private sendTitle(sender, title, subtitle?) {
+    public sendTitle(sender: any, title: string, subtitle: string = '', fadeIn: number = 20, time: number = 100, fadeOut: number = 20) {
         if (!title) return
         if (this.downgrade) {
             this.logger.sender(sender, `${title}${subtitle ? ` ${subtitle}` : ''}`)
         } else {
-            this.chat.sendTitle(sender, title, subtitle)
+            this.chat.sendTitle(sender, title, subtitle, fadeIn, time, fadeOut)
         }
     }
 
-    private setItemAndTp(sender: org.bukkit.entity.Player, content: string, sync: { scaned: boolean }) {
+    public clearTitle(sender) {
+        this.chat.clearTitle(sender)
+    }
+
+    public setItemAndTp(sender: org.bukkit.entity.Player, content: string, sync: { scaned: boolean, left?: number, cancelled?: boolean }, name: string = '手机QQ扫描二维码', tip: string = '手机QQ扫描二维码') {
         this.taskManager.create(() => {
-            let bindingLeftTime = 55
+            if (!sync.left) { sync.left = 55 }
+            sync.cancelled = false
             let task = this.taskManager.create(() => {
                 try {
-                    if (sync.scaned || !sender.isOnline() || !this.isHoldQrCodeItem(sender) || --bindingLeftTime < 0) {
-                        if (bindingLeftTime < 0) {
+                    if (sync.scaned || !sender.isOnline() || !this.isHoldQrCodeItem(sender) || --sync.left < 0) {
+                        if (sync.left < 0) {
                             this.logger.sender(sender, '§c二维码已过期 请重新获取 如已扫码请忽略!')
                             task.cancel()
                         }
                         this.cancelTask(sender)
+                        sync.cancelled = true
                         return
                     }
-                    this.sendActionBar(sender, `§c§l手机QQ扫描二维码 剩余 ${bindingLeftTime} 秒...`)
+                    this.sendActionBar(sender, `§c§l${tip} 剩余 ${sync.left} 秒...`)
                 } catch (error) {
                     console.ex(error)
                 }
@@ -610,7 +646,7 @@ export class MiaoReward extends interfaces.Plugin {
                 temp.setPitch(90)
                 sender.teleport(temp)
             }
-            this.sendWindowItems(sender, this.createQrCodeMapItem())
+            this.sendWindowItems(sender, this.createQrCodeMapItem(name))
             sender.sendMap(this.zeroMapView)
         }).submit()
     }
@@ -624,13 +660,11 @@ export class MiaoReward extends interfaces.Plugin {
             username: sender.getName(),
             sync
         })
-        if (result?.code == 200) {
-            this.playerInfoCache.set(sender.getName(), result.data)
-        }
+        this.playerInfoCache.set(sender.getName(), result?.code == 200 ? result.data : null)
         return result
     }
 
-    cmdquery(sender: org.bukkit.entity.Player) {
+    private cmdquery(sender: org.bukkit.entity.Player) {
         let info = this.queryUser(sender)
         if (info.code !== 200) {
             return this.logger.sender(sender, '§4查询异常! §cError: ' + info.msg)
@@ -648,11 +682,12 @@ export class MiaoReward extends interfaces.Plugin {
             `§6签    到: §b${data.sign}`,
             `§6视频广告: §b${data.video}`,
             `§6盒子广告: §b${data.box}`,
+            `§6积木广告: §b${data.block}`,
             '§6==========================='
         ])
     }
 
-    private httpPost(url, data) {
+    public httpPost(url, data) {
         let startTime = Date.now()
         let result = http.post(url, data)
         console.debug(`
@@ -664,7 +699,7 @@ CAST TIME   : ${Date.now() - startTime}`)
         return result
     }
 
-    private createQrCodeMapItem() {
+    private createQrCodeMapItem(name: string = '手机QQ扫描二维码') {
         let item: org.bukkit.inventory.ItemStack
         item = new org.bukkit.inventory.ItemStack(org.bukkit.Material.FILLED_MAP || org.bukkit.Material.MAP)
         let meta = <org.bukkit.inventory.meta.MapMeta>item.getItemMeta()
@@ -675,7 +710,7 @@ CAST TIME   : ${Date.now() - startTime}`)
         } else {
             item.setDurability(this.zeroMapView.getId())
         }
-        meta.setDisplayName('§c请使用手机QQ扫描二维码!')
+        meta.setDisplayName(`§c${name}`)
         meta.setLore(["QRCODE"])
         item.setItemMeta(meta)
         return item
@@ -714,31 +749,33 @@ CAST TIME   : ${Date.now() - startTime}`)
     }
 
     @Listener()
-    PlayerJoinEvent(event: org.bukkit.event.player.PlayerJoinEvent) {
+    private PlayerJoinEvent(event: org.bukkit.event.player.PlayerJoinEvent) {
         const player = event.getPlayer()
         this.bungeeCordDetect(player)
         this.updatePlayerInfo(player)
-        this.taskManager.create(() => this.logger.sender(player, `§a本服已使用喵式奖励 §3可以看广告赚${this.config.coinName} §c/mrd help §b查看帮助!`)).later(50).submit()
+        if (this.config.joinTip) {
+            this.taskManager.create(() => this.logger.sender(player, `§a本服已使用喵式奖励 §3可以看广告赚${this.config.coinName} §c/mrd help §b查看帮助!`)).later(50).submit()
+        }
     }
 
     @Listener()
-    PlayerDropItemEvent(event: org.bukkit.event.player.PlayerDropItemEvent) {
+    private PlayerDropItemEvent(event: org.bukkit.event.player.PlayerDropItemEvent) {
         if (this.checkAndClear(event.getPlayer())) {
             event.setCancelled(true)
         }
     }
 
     @Listener()
-    PlayerItemHeldEvent(event: org.bukkit.event.player.PlayerItemHeldEvent) {
+    private PlayerItemHeldEvent(event: org.bukkit.event.player.PlayerItemHeldEvent) {
         this.checkAndClear(event.getPlayer())
     }
 
     @Listener()
-    PlayerQuitEvent(event: org.bukkit.event.player.PlayerQuitEvent) {
+    private PlayerQuitEvent(event: org.bukkit.event.player.PlayerQuitEvent) {
         this.checkAndClear(event.getPlayer())
     }
 
-    private cancelTask(player) {
+    public cancelTask(player) {
         if (!this.playerTaskCache.has(player.getName())) { return }
         this.checkAndClear(player)
         this.sendActionBar(player, "")
@@ -760,7 +797,7 @@ CAST TIME   : ${Date.now() - startTime}`)
         return false
     }
 
-    cmdhelp(sender: any) {
+    private cmdhelp(sender: any) {
         let help = [
             `§6====== ${this.config.prefix} §a帮助菜单 §6======`,
             `§6/mrd bind §a绑定圈云盒子`,
@@ -785,7 +822,7 @@ CAST TIME   : ${Date.now() - startTime}`)
     }
 
     @Tab()
-    tabmrd(sender: any, _command: any, args: string | any[]) {
+    private tabmrd(sender: any, _command: any, args: string | any[]) {
         if (args.length === 1) return ['help', 'bind', 'show', 'statistic', 'query', 'draw', 'ratio', 'rank', 'server']
         if (args.length === 2 && args[0] === "bind" && sender.isOp()) return ['server']
     }

packages/plugins/src/MiaoRobot.ts

@@ -0,0 +1,102 @@
+/// <reference types="@javatypes/bungee-api" />
+/// <reference types="@javatypes/bukkit-api" />
+/// <reference types="@javatypes/sponge-api" />
+/// <reference types="typescript" />
+// @ts-ignore
+require.clear('websocket/client')
+import { server } from '@ccms/api'
+import { Autowired, Container, ContainerInstance } from '@ccms/container'
+import { Cmd, JSPlugin, Tab, interfaces, PluginConfig, Config } from '@ccms/plugin'
+import { WebSocket } from '@ccms/websocket'
+
+const defaultConfig = {
+    address: '',
+    token: ''
+}
+//https://github3.mk-proxy.ml/-----https://github.com/Mrs4s/go-cqhttp/releases/download/v0.9.34/go-cqhttp-v0.9.34-linux-amd64
+@JSPlugin({ version: '1.0.0', author: 'MiaoWoo', source: __filename })
+export class MiaoRobot extends interfaces.Plugin {
+    @Autowired()
+    private server: server.Server
+
+    private client: WebSocket
+
+    @Config()
+    private config: PluginConfig & typeof defaultConfig = defaultConfig
+
+    load() {
+    }
+
+    private downloadRobot() {
+        //https://api.github.com/repos/Mrs4s/go-cqhttp/releases?per_page=1&page=1
+    }
+
+    enable() {
+        if (!this.config.address || !this.config.token) {
+            return this.logger
+        }
+        this.cmdconnect(this.server.getConsoleSender(), this.config.address, this.config.token)
+    }
+
+    disable() {
+        this.cmdclose(this.server.getConsoleSender())
+    }
+
+    @Cmd({ autoMain: true })
+    mbot() { }
+
+    cmdconnect(sender: org.bukkit.entity.Player, address: string = this.config.address, token: string = this.config.token) {
+        if (this.client && this.client.readyState == WebSocket.OPEN) {
+            this.client.close()
+            this.client = undefined
+        }
+        if (!address || !token) {
+            return this.logger.sender(sender, '§4错误 请配置服务器地址和Token!')
+        }
+        try {
+            this.client = new WebSocket(address, '', { Authorization: `Bearer ${token}` })
+            this.initRobot(this.client)
+        } catch (error) {
+            console.ex(error)
+        }
+    }
+
+    private initRobot(client: WebSocket) {
+        client.onopen = () => {
+            this.logger.console(`§3连接到 §b${client.url} §a成功!`)
+        }
+        client.onmessage = (event) => {
+            let messageEvent = JSON.parse(event.data)
+            switch (messageEvent.post_type) {
+                case "message":
+                    this.logger.console(`§6接收到 §3群 §b${messageEvent.group_id} §2成员 §a${messageEvent.sender.nickname} §6的消息: §r${messageEvent.message}`)
+                    break
+            }
+        }
+        client.onclose = (event) => {
+            this.logger.console(`§4连接已断开 §6Code: §3${event.code} §6原因: §c${event.reason}!`)
+        }
+        client.onerror = (event) => {
+            this.logger.console(`§4发生错误: §r${event.error}`)
+            console.ex(event.error)
+        }
+    }
+
+    cmdclose(sender: org.bukkit.entity.Player) {
+        if (this.client) {
+            this.client.close(0, 'plugin close socket')
+        }
+    }
+
+    cmdsend(sender: org.bukkit.entity.Player, text: string) {
+        if (this.client) {
+            this.client.send(text)
+            this.logger.sender(sender, '§a发送成功!')
+        }
+    }
+
+    @Tab()
+    tabmbot(_sender: any, _command: string, _args: string[]) {
+        return []
+    }
+}

packages/plugins/src/MiaoScriptPackageManager.ts

@@ -15,8 +15,9 @@ let help = [
     '§6/mspm §areload §e<插件名称>   §6-  §3重载已安装插件(无名称则重载自身)',
     '§6/mspm §alist [i]            §6-  §3列出仓库插件[已安装的插件]',
     '§6/mspm §aupdate §e[插件名称]   §6-  §3更新插件(无名称则更新源)',
-    '§6/mspm §aupgrade §e[插件名称]  §6-  §3升级插件/框架(§4无名称则升级框架§3)',
-    '§6/mspm §arun §e<JS代码>        §6-  §3运行JS代码',
+    '§6/mspm §aupgrade §e[插件名称|system]  §6-  §3升级插件/§4框架(§csystem§3)',
+    '§6/mspm §arun §e[插件名称] §3<JS代码>        §6-  §3运行JS代码',
+    '§6/mspm §aprun  §e<JS代码>        §6-  §3运行JS代码',
     '§6/mspm §adeploy §e<插件名称>   §6-  §3发布插件',
     '§6/mspm §crestart             §6-  §4重启MiaoScript脚本引擎'
 ]
@@ -132,6 +133,7 @@ export class MiaoScriptPackageManager extends interfaces.Plugin {
     public serverName: string
     private translate: Translate
     private channelOff: { off: () => void }
+    private subCommandCache = []
 
     load() {
         this.translate = new Translate({
@@ -139,6 +141,7 @@ export class MiaoScriptPackageManager extends interfaces.Plugin {
             fallbackMap
         })
         this.updateRepo(this.server.getConsoleSender())
+        this.subCommandCache = Object.keys(this).filter(c => c.startsWith('cmd') && typeof this[c] == "function")
     }
 
     @enable({ servers: [constants.ServerType.Bukkit, constants.ServerType.Sponge] })
@@ -383,7 +386,7 @@ export class MiaoScriptPackageManager extends interfaces.Plugin {
     }
 
     cmdrestart(sender: any) {
-        setTimeout(() => {
+        this.taskManager.callSyncMethod(() => {
             if (this.serverType === "sponge") {
                 this.server.dispatchConsoleCommand('sponge plugins reload')
                 return
@@ -398,7 +401,7 @@ export class MiaoScriptPackageManager extends interfaces.Plugin {
                 this.logger.sender(sender, "§3MiaoScript Engine §6Reload §cError! ERR: " + ex)
                 this.logger.sender(sender, this.logger.stack(ex))
             }
-        }, 0)
+        })
     }
 
     cmdrun(sender: any, ...args: any[]) {
@@ -477,7 +480,7 @@ return eval(${JSON.stringify(code)});`)
 
     @Tab({ alias: ['gmspm', 'bungeemspm'] })
     tabmspm(_sender: any, _command: any, args: string | any[]) {
-        if (args.length === 1) { return ['list', 'install', 'update', 'upgrade', 'reload', 'restart', 'run', 'prun', 'sudo', 'help', 'create', 'deploy'] }
+        if (args.length === 1) { return ['list', 'install', 'update', 'load', 'unload', 'upgrade', 'reload', 'restart', 'run', 'prun', 'sudo', 'help', 'create', 'deploy'] }
         if (args.length > 1) {
             switch (args[0]) {
                 case "list":

packages/protocol/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ccms/protocol",
-    "version": "0.10.1",
+    "version": "0.13.0",
     "description": "MiaoScript protocol package",
     "keywords": [
         "miaoscript",

packages/sponge/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ccms/sponge",
-    "version": "0.10.1",
+    "version": "0.13.0",
     "description": "MiaoScript api package",
     "keywords": [
         "miaoscript",
@@ -25,8 +25,8 @@
         "typescript": "^4.0.5"
     },
     "dependencies": {
-        "@ccms/api": "^0.10.1",
-        "@ccms/common": "^0.10.1",
-        "@ccms/container": "^0.10.1"
+        "@ccms/api": "^0.13.0",
+        "@ccms/common": "^0.13.0",
+        "@ccms/container": "^0.13.0"
     }
 }

packages/sponge/src/index.ts

@@ -8,9 +8,12 @@ import './chat'
 import './task'
 import './event'
 import './server'
+import { SpongeNativePluginManager } from './plugin'
 import './command'
 import './channel'
+import './particle'
 
 export default function SpongeImpl(container: Container) {
     container.bind(server.Console).toConstantValue(SpongeConsole)
+    container.rebind(server.NativePluginManager).toConstantValue(new SpongeNativePluginManager())
 }

packages/sponge/src/particle.ts

@@ -0,0 +1,32 @@
+import { provideSingleton } from '@ccms/container'
+import { particle, plugin } from '@ccms/api'
+
+@provideSingleton(particle.ParticleManager)
+export class SpongeParticleManager extends particle.ParticleManager {
+    private globalSpawner = new SpongeParticleSpawner()
+    constructor() {
+        super()
+        particle.ParticleManager.globalSpawner = this.globalSpawner
+    }
+    protected getGlobalSpawner() {
+        return this.globalSpawner
+    }
+}
+export class SpongeParticleSpawner extends particle.ParticleSpawner {
+    spawnParticle(location: org.spongepowered.api.world.Location<any>, particle: any, count: number = 1) {
+        location.getPosition()
+        // location.getWorld().spawnParticle(particle, location, count)
+    }
+    spawn(location: any, particle: particle.Particle) {
+        location.getWorld().spawnParticle(
+            particle.getParticle(),
+            location,
+            particle.getCount(),
+            particle.getOffsetX(),
+            particle.getOffsetY(),
+            particle.getOffsetZ(),
+            particle.getExtra(),
+            particle.getData()
+        )
+    }
+}

packages/sponge/src/plugin.ts

@@ -0,0 +1,12 @@
+import { server } from '@ccms/api'
+
+const Sponge = org.spongepowered.api.Sponge
+
+export class SpongeNativePluginManager extends server.NativePluginManager {
+    has(name: string) {
+        return !!this.get(name)
+    }
+    get(name: string) {
+        return Sponge.getPluginManager().getPlugin(name).orElse(null)
+    }
+}

packages/sponge/src/server.ts

@@ -4,7 +4,6 @@ import { provideSingleton } from '@ccms/container'
 import * as reflect from '@ccms/common/dist/reflect'
 
 const Sponge = org.spongepowered.api.Sponge
-const TextSerializers = org.spongepowered.api.text.serializer.TextSerializers
 const File = Java.type("java.io.File")
 
 @provideSingleton(server.Server)
@@ -35,10 +34,10 @@ export class SpongeServer extends server.ReflectServer {
         if (typeof sender === 'string') {
             sender = this.getPlayer(sender)
         }
-        return Sponge.getCommandManager().process(sender, command).getSuccessCount().get() != 0
+        return Sponge.getCommandManager().process(sender, command).getSuccessCount().orElse(0) != 0
     }
     dispatchConsoleCommand(command: string): boolean {
-        return Sponge.getCommandManager().process(Sponge.getServer().getConsole(), command).getSuccessCount().get() != 0
+        return Sponge.getCommandManager().process(Sponge.getServer().getConsole(), command).getSuccessCount().orElse(0) != 0
     }
     getPluginsFolder(): string {
         return this.pluginsFolder

packages/sponge/src/task.ts

@@ -20,8 +20,7 @@ export class SpongeTaskManager extends task.TaskManager {
         return new SpongeTask(owner, func, id)
     }
     callSyncMethod(func: Function): any {
-        // @ts-ignore
-        return this.syncExecutor.schedule(new Callable({ call: () => func() }), java.lang.Long.valueOf(0), TimeUnit.NANOSECONDS).get()
+        return this.syncExecutor.execute(() => func())
     }
     disable0() {
         Sponge.getScheduler().getScheduledTasks(base.getInstance()).forEach((task: task.Cancelable) => task.cancel())

packages/spring/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ccms/spring",
-    "version": "0.10.1",
+    "version": "0.13.0",
     "description": "MiaoScript spring package",
     "keywords": [
         "miaoscript",
@@ -24,9 +24,9 @@
         "typescript": "^4.0.5"
     },
     "dependencies": {
-        "@ccms/api": "^0.10.1",
-        "@ccms/common": "^0.10.1",
-        "@ccms/container": "^0.10.1",
-        "@ccms/database": "^0.10.1"
+        "@ccms/api": "^0.13.0",
+        "@ccms/common": "^0.13.0",
+        "@ccms/container": "^0.13.0",
+        "@ccms/database": "^0.13.0"
     }
 }

packages/web/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ccms/web",
-    "version": "0.10.1",
+    "version": "0.13.0",
     "description": "MiaoScript web package",
     "keywords": [
         "miaoscript",
@@ -29,7 +29,7 @@
         "typescript": "^4.0.5"
     },
     "dependencies": {
-        "@ccms/api": "^0.10.1",
-        "@ccms/container": "^0.10.1"
+        "@ccms/api": "^0.13.0",
+        "@ccms/container": "^0.13.0"
     }
 }

packages/websocket/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ccms/websocket",
-    "version": "0.10.1",
+    "version": "0.13.0",
     "description": "MiaoScript websocket package",
     "keywords": [
         "miaoscript",
@@ -19,7 +19,7 @@
         "test": "echo \"Error: run tests from root\" && exit 1"
     },
     "devDependencies": {
-        "@ccms/nashorn": "^0.10.1",
+        "@ccms/nashorn": "^0.13.0",
         "@javatypes/tomcat-websocket-api": "^0.0.3",
         "reflect-metadata": "^0.1.13",
         "rimraf": "^3.0.2",

packages/websocket/src/client/index.ts

@@ -0,0 +1,98 @@
+
+import { EventEmitter } from 'events'
+import { Transport } from './transport'
+import { CloseEvent, ErrorEvent, Event, EventType, MessageEvent, WebSocketHeader } from './interface'
+
+export class WebSocketManager {
+    private clients = new Map<string, WebSocket>()
+
+    constructor() {
+        process.on('exit', () => {
+            for (const client of this.clients.values()) {
+                client.close(0, `client ${client.id} close connect`)
+            }
+            this.clients.clear()
+        })
+    }
+
+    add(client: WebSocket) {
+        this.clients.set(client.id, client)
+    }
+    del(client: WebSocket) {
+        this.clients.delete(client.id)
+    }
+}
+
+export const managers = new WebSocketManager()
+
+export class WebSocket extends EventEmitter {
+    public static CONNECTING = 0
+    public static OPEN = 1
+    public static CLOSING = 2
+    public static CLOSED = 3
+    public binaryType: 'blob' | 'arraybuffer'
+
+    protected _url: string
+    protected _headers: WebSocketHeader = {}
+
+    private client: Transport
+
+    constructor(url: string, subProtocol: string = '', headers: WebSocketHeader = {}) {
+        super()
+        this._url = url
+        this._headers = headers
+        try {
+            let TransportImpl = require('./netty').NettyWebSocket
+            this.client = new TransportImpl(url, subProtocol, headers)
+        } catch (error) {
+            console.error('create websocket impl error: ' + error)
+            console.ex(error)
+            return
+        }
+        this.client.on('open', (event) => {
+            this.onopen?.(event)
+            managers.add(this)
+        })
+        this.client.on('message', (event) => this.onmessage?.(event))
+        this.client.on('close', (event) => {
+            this.onclose?.(event)
+            managers.del(this)
+        })
+        this.client.on('error', (event) => this.onerror?.(event))
+        setTimeout(() => this.client.connect(), 20)
+    }
+    get id() {
+        return this.client.id
+    }
+    get bufferedAmount() {
+        throw new Error("Method not implemented.")
+    }
+    get extensions() {
+        throw new Error("Method not implemented.")
+    }
+    get protocol() {
+        return this.client.protocol
+    }
+    get readyState() {
+        return this.client.readyStatus
+    }
+    get url() {
+        return this._url
+    }
+    public onopen: (event: Event) => void
+    public onmessage: (event: MessageEvent) => void
+    public onclose: (event: CloseEvent) => void
+    public onerror: (event: ErrorEvent) => void
+
+    addEventListener(event: EventType, callback: () => void) {
+        this[`on${event.toLowerCase()}`] = callback
+        this.client.on(event, callback)
+    }
+    public send(data: any) {
+        this.client.send(data)
+    }
+    public close(code?: number, reason?: string) {
+        this.client.close(code, reason)
+        this.removeAllListeners()
+    }
+}

packages/websocket/src/client/interface.ts

@@ -0,0 +1,27 @@
+
+export interface WebSocketHeader {
+    [key: string]: string
+}
+
+export type EventType =
+    | 'close'
+    | 'error'
+    | 'message'
+    | 'open'
+export interface Event {
+
+}
+export interface MessageEvent extends Event {
+    data: any
+    origin?: string
+    lastEventId?: string
+    source?: string
+    ports?: string
+}
+export interface ErrorEvent extends Event {
+    error: Error
+}
+export interface CloseEvent extends Event {
+    code: number
+    reason: string
+}

packages/websocket/src/client/netty/adapter/handler.ts

@@ -0,0 +1,24 @@
+const SimpleChannelInboundHandler = Java.type('io.netty.channel.SimpleChannelInboundHandler')
+export abstract class WebSocketClientHandlerAdapter {
+    private _Handler
+    constructor() {
+        let WebSocketClientHandlerAdapterImpl = Java.extend(SimpleChannelInboundHandler, {
+            isSharable: this.isSharable.bind(this),
+            handlerAdded: this.handlerAdded.bind(this),
+            channelActive: this.channelActive.bind(this),
+            channelInactive: this.channelInactive.bind(this),
+            channelRead0: this.channelRead0.bind(this),
+            exceptionCaught: this.exceptionCaught.bind(this)
+        })
+        this._Handler = new WebSocketClientHandlerAdapterImpl()
+    }
+    abstract isSharable(): void
+    abstract handlerAdded(ctx: any): void
+    abstract channelActive(ctx: any): void
+    abstract channelInactive(ctx: any): void
+    abstract channelRead0(ctx: any, msg: any): void
+    abstract exceptionCaught(ctx: any, cause: Error): void
+    getHandler() {
+        return this._Handler
+    }
+}

packages/websocket/src/client/netty/handler.ts

@@ -0,0 +1,63 @@
+import { EventEmitter } from 'events'
+import { NettyWebSocket } from '.'
+import { WebSocketClientHandlerAdapter } from './adapter/handler'
+
+const CharsetUtil = Java.type('io.netty.util.CharsetUtil')
+const TextWebSocketFrame = Java.type('io.netty.handler.codec.http.websocketx.TextWebSocketFrame')
+const CloseWebSocketFrame = Java.type('io.netty.handler.codec.http.websocketx.CloseWebSocketFrame')
+const FullHttpResponse = Java.type('io.netty.handler.codec.http.FullHttpResponse')
+
+export class WebSocketClientHandler extends WebSocketClientHandlerAdapter {
+    public handshaker: any
+    public handshakeFuture: any//ChannelPromise
+    private client: NettyWebSocket
+    constructor(handshaker: any, client: NettyWebSocket) {
+        super()
+        this.handshaker = handshaker
+        this.client = client
+    }
+    isSharable() {
+        return true
+    }
+    handlerAdded(ctx: any) {
+        console.trace(`${ctx} handlerAdded`)
+        this.handshakeFuture = ctx.newPromise()
+    }
+    channelActive(ctx: any) {
+        console.trace(`${ctx} channelActive`)
+        this.handshaker.handshake(ctx.channel())
+    }
+    channelInactive(ctx: any) {
+        console.trace(`${ctx} channelInactive`)
+        this.client.onclose({ code: 0, reason: 'server connection channel inactive!' })
+    }
+    channelRead0(ctx: any, msg: any) {
+        console.trace(`${ctx} channelRead0 ${msg}`)
+        let ch = ctx.channel()
+        if (!this.handshaker.isHandshakeComplete()) {
+            // web socket client connected
+            this.handshaker.finishHandshake(ch, msg)
+            this.handshakeFuture.setSuccess()
+            return
+        }
+
+        if (msg instanceof FullHttpResponse) {
+            let response = msg
+            throw new Error(`Unexpected FullHttpResponse (getStatus=${response.getStatus()}, content=${response.content().toString(CharsetUtil.UTF_8)})`)
+        }
+
+        let frame = msg
+        if (frame instanceof TextWebSocketFrame) {
+            this.client.onmessage({ data: frame.text() })
+        } else if (frame instanceof CloseWebSocketFrame) {
+            this.client.onclose({ code: 0, reason: 'server send CloseWebSocketFrame!' })
+        }
+    }
+    exceptionCaught(ctx: any, cause: Error) {
+        console.trace(`${ctx} exceptionCaught ${cause}`)
+        this.client.onerror({ error: cause })
+        if (!this.handshakeFuture.isDone()) {
+            this.handshakeFuture.setFailure(cause)
+        }
+    }
+}

packages/websocket/src/client/netty/index.ts

@@ -0,0 +1,88 @@
+
+import { WebSocketHeader } from '../interface'
+import { Transport } from '../transport'
+import { WebSocketClientHandler } from './handler'
+
+const URI = Java.type('java.net.URI')
+const Epoll = Java.type('io.netty.channel.epoll.Epoll')
+const Bootstrap = Java.type('io.netty.bootstrap.Bootstrap')
+const ChannelFutureListener = Java.type('io.netty.channel.ChannelFutureListener')
+
+const NioEventLoopGroup = Java.type('io.netty.channel.nio.NioEventLoopGroup')
+const NioSocketChannel = Java.type('io.netty.channel.socket.nio.NioSocketChannel')
+
+const EpollEventLoopGroup = Java.type('io.netty.channel.epoll.EpollEventLoopGroup')
+const EpollSocketChannel = Java.type('io.netty.channel.epoll.EpollSocketChannel')
+
+const WebSocketClientHandshakerFactory = Java.type('io.netty.handler.codec.http.websocketx.WebSocketClientHandshakerFactory')
+const WebSocketVersion = Java.type('io.netty.handler.codec.http.websocketx.WebSocketVersion')
+
+const HttpClientCodec = Java.type('io.netty.handler.codec.http.HttpClientCodec')
+const HttpObjectAggregator = Java.type('io.netty.handler.codec.http.HttpObjectAggregator')
+const TextWebSocketFrame = Java.type('io.netty.handler.codec.http.websocketx.TextWebSocketFrame')
+const CloseWebSocketFrame = Java.type('io.netty.handler.codec.http.websocketx.CloseWebSocketFrame')
+
+const ChannelInitializer = Java.type('io.netty.channel.ChannelInitializer')
+const DefaultHttpHeaders = Java.type('io.netty.handler.codec.http.DefaultHttpHeaders')
+
+const epull = Epoll.isAvailable()
+const group = epull ? new EpollEventLoopGroup() : new NioEventLoopGroup()
+const socketChannelClass = epull ? EpollSocketChannel.class : NioSocketChannel.class
+process.on('exit', () => group.shutdownGracefully())
+
+export class NettyWebSocket extends Transport {
+    private channel: any
+    private b = new Bootstrap();
+
+    constructor(url: string, subProtocol: string = '', headers: WebSocketHeader = {}) {
+        super(url, subProtocol, headers)
+    }
+    getId() {
+        return this.channel?.id() + ''
+    }
+    doConnect() {
+        let uri = URI.create(this._url)
+        let headers = new DefaultHttpHeaders()
+        for (const key of Object.getOwnPropertyNames(this._headers || {})) {
+            headers.add(key, this._headers[key])
+        }
+        // Connect with V13 (RFC 6455 aka HyBi-17). You can change it to V08 or V00.
+        // If you change it to V00, ping is not supported and remember to change
+        // HttpResponseDecoder to WebSocketHttpResponseDecoder in the pipeline.
+        let handler = new WebSocketClientHandler(WebSocketClientHandshakerFactory
+            .newHandshaker(uri, WebSocketVersion.V13, null, false, headers), this)
+        this.b.group(group)
+            .channel(socketChannelClass)
+            .handler(new ChannelInitializer({
+                initChannel: (ch: any) => {
+                    let pipeline = ch.pipeline()
+                    pipeline.addLast("http-codec", new HttpClientCodec())
+                    pipeline.addLast("aggregator", new HttpObjectAggregator(65536))
+                    pipeline.addLast("websocket", handler.getHandler())
+                }
+            }))
+        this.b.connect(uri.getHost(), uri.getPort()).addListener(new ChannelFutureListener((future: any) => {
+            this.channel = future.sync().channel()
+            this.onconnection({})
+            handler.handshakeFuture.addListener(new ChannelFutureListener((future: any) => {
+                try {
+                    future.sync()
+                    this.onconnect({})
+                } catch (error) {
+                    console.debug(error)
+                }
+            }))
+        }))
+    }
+    doSend(text: string) {
+        this.channel.writeAndFlush(new TextWebSocketFrame(text))
+    }
+    doClose(code: number, reason: string) {
+        this.channel.writeAndFlush(new CloseWebSocketFrame())
+        this.channel.close()
+        this.channel.closeFuture().addListener(new ChannelFutureListener(() => console.debug(`NettyWebSocket close code: ${code} reason: ${reason}`)))
+    }
+    getChannel() {
+        return this.channel
+    }
+}

packages/websocket/src/client/transport.ts

@@ -0,0 +1,100 @@
+import { EventEmitter } from 'events'
+import { WebSocket } from './index'
+import { CloseEvent, ErrorEvent, Event, MessageEvent, WebSocketHeader } from './interface'
+
+export abstract class Transport extends EventEmitter {
+    protected _url: string
+    protected _state: number = WebSocket.CONNECTING
+    protected _protocol: string
+    protected _headers: WebSocketHeader = {}
+
+    constructor(uri: string, subProtocol: string = '', headers: WebSocketHeader = {}) {
+        super()
+        this._url = uri
+        this._protocol = subProtocol
+        this._headers = headers
+    }
+
+    get id() {
+        return this.getId()
+    }
+
+    get protocol() {
+        return this._protocol
+    }
+
+    get readyStatus() {
+        return this._state
+    }
+
+    set readyStatus(state: number) {
+        this._state = state
+    }
+
+    connect() {
+        try {
+            this.doConnect()
+        } catch (error) {
+            this.onerror({ error })
+        }
+    }
+
+    send(text: string) {
+        try {
+            this.doSend(text)
+        } catch (error) {
+            this.onerror({ error })
+        }
+    }
+
+    close(code: number = 0, reason: string = '') {
+        if (this.readyStatus != WebSocket.CLOSING && this.readyStatus != WebSocket.CLOSED) {
+            this.readyStatus = WebSocket.CLOSING
+            try {
+                this.onclose({ code, reason })
+                this.doClose(code, reason)
+            } catch (error) {
+                this.onerror({ error })
+            }
+        } else {
+            console.debug(`${this.id} call close but state is ${this.readyStatus}`)
+        }
+    }
+
+    onconnection(event: Event) {
+        this._state == WebSocket.CONNECTING
+        this.emit('connecting', event)
+    }
+
+    onconnect(event: Event) {
+        console.debug(`${this.id} call onconnect`)
+        if (this.readyStatus != WebSocket.OPEN) {
+            this.readyStatus = WebSocket.OPEN
+            this.emit('open', event)
+        } else {
+            console.debug(`${this.id} call onconnect but state is ${this.readyStatus}`)
+        }
+    }
+
+    onmessage(event: MessageEvent) {
+        this.emit('message', event)
+    }
+
+    onerror(event: ErrorEvent) {
+        this.emit('error', event)
+    }
+
+    onclose(event: CloseEvent) {
+        if (this.readyStatus != WebSocket.CLOSED) {
+            this.readyStatus = WebSocket.CLOSED
+            this.emit('close', event)
+            this.removeAllListeners()
+        } else {
+            console.debug(`${this.id} call onclose but state is ${this.readyStatus} CloseEvent[code: ${event.code}, reason: ${event.reason}]`)
+        }
+    }
+    abstract getId()
+    abstract doConnect()
+    abstract doSend(text: string)
+    abstract doClose(code: number, reason: string)
+}

packages/websocket/src/index.ts

@@ -4,44 +4,48 @@
 import { Server, ServerOptions } from './socket-io'
 
 interface SocketIOStatic {
-	/**
-	 * Default Server constructor
-	 */
-	(): Server
+    /**
+     * Default Server constructor
+     */
+    (): Server
 
-	/**
-	 * Creates a new Server
-	 * @param srv The HTTP server that we're going to bind to
-	 * @param opts An optional parameters object
-	 */
-	(srv: any, opts?: ServerOptions): Server
+    /**
+     * Creates a new Server
+     * @param srv The HTTP server that we're going to bind to
+     * @param opts An optional parameters object
+     */
+    (srv: any, opts?: Partial<ServerOptions>): Server
 
-	/**
-	 * Creates a new Server
-	 * @param port A port to bind to, as a number, or a string
-	 * @param An optional parameters object
-	 */
-	(port: string | number, opts?: ServerOptions): Server
+    /**
+     * Creates a new Server
+     * @param port A port to bind to, as a number, or a string
+     * @param An optional parameters object
+     */
+    (port: string | number, opts?: Partial<ServerOptions>): Server
 
-	/**
-	 * Creates a new Server
-	 * @param A parameters object
-	 */
-	(opts: ServerOptions): Server
+    /**
+     * Creates a new Server
+     * @param A parameters object
+     */
+    (opts: Partial<ServerOptions>): Server
 
-	/**
-	 * Backwards compatibility
-	 * @see io().listen()
-	 */
-	listen?: SocketIOStatic
+    /**
+     * Backwards compatibility
+     * @see io().listen()
+     */
+    listen?: SocketIOStatic
 }
 
 type SocketStatic = SocketIOStatic & { Instance?: symbol }
 
 // @ts-ignore
-let io: SocketStatic = function (pipeline: any, options: ServerOptions) {
-	return new Server(pipeline, options)
+let io: SocketStatic = function (pipeline: any, options: Partial<ServerOptions>) {
+    return new Server(pipeline, options)
 }
 io.Instance = Symbol("@ccms/websocket")
 export default io
 export * from './socket-io'
+export * from './client'
+export * from './netty'
+export * from './tomcat'
+export * from './transport'

packages/websocket/src/netty/adapter/httprequest.ts

@@ -0,0 +1,20 @@
+const TypeParameterMatcher = Java.type('io.netty.util.internal.TypeParameterMatcher')
+const SimpleChannelInboundHandler = Java.type('io.netty.channel.SimpleChannelInboundHandler')
+const FullHttpRequestMatcher = TypeParameterMatcher.get(base.getClass('io.netty.handler.codec.http.FullHttpRequest'))
+
+export abstract class HttpRequestHandlerAdapter {
+    private _Handler;
+    constructor() {
+        let HttpRequestHandlerAdapterImpl = Java.extend(SimpleChannelInboundHandler, {
+            acceptInboundMessage: (msg: any) => {
+                return FullHttpRequestMatcher.match(msg)
+            },
+            channelRead0: this.channelRead0.bind(this)
+        })
+        this._Handler = new HttpRequestHandlerAdapterImpl();
+    }
+    abstract channelRead0(ctx: any, request: any);
+    getHandler() {
+        return this._Handler;
+    }
+}

packages/websocket/src/netty/adapter/index.ts

@@ -0,0 +1,3 @@
+export * from './text_websocket_frame'
+export * from './websocket'
+export * from './httprequest'

packages/websocket/src/netty/adapter/text_websocket_frame.ts

@@ -0,0 +1,24 @@
+const TypeParameterMatcher = Java.type('io.netty.util.internal.TypeParameterMatcher')
+const TextWebSocketFrameMatcher = TypeParameterMatcher.get(base.getClass('io.netty.handler.codec.http.websocketx.TextWebSocketFrame'))
+const SimpleChannelInboundHandler = Java.type('io.netty.channel.SimpleChannelInboundHandler')
+
+export abstract class TextWebSocketFrameHandlerAdapter {
+    private _Handler
+    constructor() {
+        let TextWebSocketFrameHandlerAdapterImpl = Java.extend(SimpleChannelInboundHandler, {
+            userEventTriggered: this.userEventTriggered.bind(this),
+            acceptInboundMessage: (msg: any) => {
+                return TextWebSocketFrameMatcher.match(msg)
+            },
+            channelRead0: this.channelRead0.bind(this),
+            exceptionCaught: this.exceptionCaught.bind(this)
+        })
+        this._Handler = new TextWebSocketFrameHandlerAdapterImpl()
+    }
+    abstract userEventTriggered(ctx: any, evt: any)
+    abstract channelRead0(ctx: any, msg: any)
+    abstract exceptionCaught(ctx: any, cause: Error)
+    getHandler() {
+        return this._Handler
+    }
+}

packages/websocket/src/netty/adapter/websocket.ts

@@ -5,13 +5,19 @@ export abstract class WebSocketHandlerAdapter {
     constructor() {
         let ChannelInboundHandlerAdapterImpl = Java.extend(ChannelInboundHandlerAdapter, {
             channelRead: this.channelRead.bind(this),
+            channelInactive: this.channelInactive.bind(this),
             channelUnregistered: this.exceptionCaught.bind(this),
             exceptionCaught: this.exceptionCaught.bind(this)
         })
         this._Handler = new ChannelInboundHandlerAdapterImpl()
     }
     abstract channelRead(ctx: any, channel: any)
-    abstract channelUnregistered(ctx: any)
+    channelInactive(ctx: any) {
+        ctx.fireChannelInactive()
+    }
+    channelUnregistered(ctx: any) {
+        ctx.fireChannelUnregistered()
+    }
     abstract exceptionCaught(ctx: any, cause: Error)
     getHandler() {
         return this._Handler

packages/websocket/src/netty/client.ts

@@ -0,0 +1,24 @@
+import { Transport } from '../transport'
+import { AttributeKeys } from './constants'
+
+const TextWebSocketFrame = Java.type('io.netty.handler.codec.http.websocketx.TextWebSocketFrame')
+
+export class NettyClient extends Transport {
+    private channel: any
+
+    constructor(server: any, channel: any) {
+        super(server)
+        this.remoteAddress = channel.remoteAddress() + ''
+        this.request = channel.attr(AttributeKeys.Request).get()
+
+        this._id = channel.id() + ''
+        this.channel = channel
+    }
+
+    doSend(text: string) {
+        this.channel.writeAndFlush(new TextWebSocketFrame(text))
+    }
+    doClose() {
+        this.channel.close()
+    }
+}

packages/websocket/src/netty/httprequest.ts

@@ -1,20 +1,61 @@
-const TypeParameterMatcher = Java.type('io.netty.util.internal.TypeParameterMatcher')
-const SimpleChannelInboundHandler = Java.type('io.netty.channel.SimpleChannelInboundHandler')
-const FullHttpRequestMatcher = TypeParameterMatcher.get(base.getClass('io.netty.handler.codec.http.FullHttpRequest'))
+import { HttpRequestHandlerAdapter } from './adapter'
+import { AttributeKeys } from './constants'
+import { ServerOptions } from 'socket-io'
 
-export abstract class HttpRequestHandlerAdapter {
-    private _Handler;
-    constructor() {
-        let HttpRequestHandlerAdapterImpl = Java.extend(SimpleChannelInboundHandler, {
-            acceptInboundMessage: (msg: any) => {
-                return FullHttpRequestMatcher.match(msg)
-            },
-            channelRead0: this.channelRead0.bind(this)
-        })
-        this._Handler = new HttpRequestHandlerAdapterImpl();
+const DefaultHttpResponse = Java.type('io.netty.handler.codec.http.DefaultHttpResponse')
+const DefaultFullHttpResponse = Java.type('io.netty.handler.codec.http.DefaultFullHttpResponse')
+const HttpHeaders = Java.type('io.netty.handler.codec.http.HttpHeaders')
+const HttpVersion = Java.type('io.netty.handler.codec.http.HttpVersion')
+const HttpResponseStatus = Java.type('io.netty.handler.codec.http.HttpResponseStatus')
+const LastHttpContent = Java.type('io.netty.handler.codec.http.LastHttpContent')
+
+const File = Java.type('java.io.File')
+const Runnable = Java.type('java.lang.Runnable')
+const RandomAccessFile = Java.type('java.io.RandomAccessFile')
+const DefaultFileRegion = Java.type('io.netty.channel.DefaultFileRegion')
+const ChannelFutureListener = Java.type('io.netty.channel.ChannelFutureListener')
+
+export class HttpRequestHandler extends HttpRequestHandlerAdapter {
+    private ws: string
+    private root: string
+    constructor(options: ServerOptions) {
+        super()
+        this.root = options.root
+        this.ws = options.path
     }
-    abstract channelRead0(ctx: any, request: any);
-    getHandler() {
-        return this._Handler;
+    channelRead0(ctx: any, request: any) {
+        if (request.getUri().startsWith(this.ws)) {
+            ctx.channel().attr(AttributeKeys.Request).set(request)
+            ctx.fireChannelRead(request.retain())
+        } else {
+            ctx.executor().execute(new Runnable({
+                run: () => {
+                    if (HttpHeaders.is100ContinueExpected(request)) {
+                        ctx.writeAndFlush(new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.CONTINUE))
+                    }
+                    let filename = request.getUri().split('?')[0].substr(1)
+                    let file = new File(this.root, filename || 'index.html')
+                    if (!file.exists() || !file.isFile()) {
+                        ctx.write(new DefaultHttpResponse(request.getProtocolVersion(), HttpResponseStatus.NOT_FOUND))
+                        ctx.writeAndFlush(LastHttpContent.EMPTY_LAST_CONTENT).addListener(ChannelFutureListener.CLOSE)
+                        return
+                    }
+                    let response = new DefaultHttpResponse(request.getProtocolVersion(), HttpResponseStatus.OK)
+                    response.headers().set(HttpHeaders.Names.CONTENT_TYPE, "text/html charset=UTF-8")
+                    let raf = new RandomAccessFile(file, 'r')
+                    let keepAlive = HttpHeaders.isKeepAlive(request)
+                    if (keepAlive) {
+                        response.headers().set(HttpHeaders.Names.CONTENT_LENGTH, file.length())
+                        response.headers().set(HttpHeaders.Names.CONNECTION, HttpHeaders.Values.KEEP_ALIVE)
+                    }
+                    ctx.write(response)
+                    ctx.write(new DefaultFileRegion(raf.getChannel(), 0, raf.length()))
+                    let future = ctx.writeAndFlush(LastHttpContent.EMPTY_LAST_CONTENT)
+                    if (!keepAlive) {
+                        future.addListener(ChannelFutureListener.CLOSE)
+                    }
+                }
+            }))
+        }
     }
 }

packages/websocket/src/netty/index.ts

@@ -1,3 +1,69 @@
-export * from './text_websocket_frame'
-export * from './websocket'
-export * from './httprequest'
+import { EventEmitter } from 'events'
+
+import { ServerOptions } from '../socket-io'
+import { ServerEvent } from '../socket-io/constants'
+
+import { NettyClient } from './client'
+import { Keys } from './constants'
+import { WebSocketDetect } from './websocket_detect'
+import { WebSocketHandler } from './websocket_handler'
+
+class NettyWebSocketServer extends EventEmitter {
+    private pipeline: any
+    private clients: Map<string, NettyClient>
+
+    constructor(pipeline: any, options: ServerOptions) {
+        super()
+        this.clients = new Map()
+        this.pipeline = pipeline
+        let connectEvent = options.event
+        try { this.pipeline.remove(Keys.Detect) } catch (error) { }
+        this.pipeline.addFirst(Keys.Detect, new WebSocketDetect(connectEvent).getHandler())
+        connectEvent.on(ServerEvent.detect, (ctx, channel) => {
+            channel.pipeline().addFirst(Keys.Handler, new WebSocketHandler(options).getHandler())
+            ctx.fireChannelRead(channel)
+        })
+        connectEvent.on(ServerEvent.connect, (ctx) => {
+            let cid = ctx?.channel().id() + ''
+            let nettyClient = new NettyClient(this, ctx.channel())
+            this.clients.set(cid, nettyClient)
+            this.emit(ServerEvent.connect, nettyClient)
+        })
+        connectEvent.on(ServerEvent.message, (ctx, msg) => {
+            let cid = ctx?.channel().id() + ''
+            if (this.clients.has(cid)) {
+                this.emit(ServerEvent.message, this.clients.get(cid), msg.text())
+            } else {
+                console.error(`unknow client ${ctx} reciver message ${msg.text()}`)
+            }
+        })
+        connectEvent.on(ServerEvent.disconnect, (ctx, cause) => {
+            let cid = ctx?.channel().id() + ''
+            if (this.clients.has(cid)) {
+                this.emit(ServerEvent.disconnect, this.clients.get(cid), cause)
+            } else {
+                console.error(`unknow client ${ctx} disconnect cause ${cause}`)
+            }
+        })
+        connectEvent.on(ServerEvent.error, (ctx, cause) => {
+            let cid = ctx?.channel().id() + ''
+            if (this.clients.has(cid)) {
+                this.emit(ServerEvent.error, this.clients.get(cid), cause)
+            } else {
+                console.error(`unknow client ${ctx} cause error ${cause}`)
+                console.ex(cause)
+            }
+        })
+    }
+    close() {
+        if (this.pipeline.names().contains(Keys.Detect)) {
+            this.pipeline.remove(Keys.Detect)
+        }
+        this.clients.forEach(client => client.close())
+    }
+}
+
+export {
+    NettyWebSocketServer,
+    NettyClient
+}

packages/websocket/src/netty/text_websocket_frame.ts

@@ -1,24 +1,23 @@
-const TypeParameterMatcher = Java.type('io.netty.util.internal.TypeParameterMatcher')
-const TextWebSocketFrameMatcher = TypeParameterMatcher.get(base.getClass('io.netty.handler.codec.http.websocketx.TextWebSocketFrame'))
-const SimpleChannelInboundHandler = Java.type('io.netty.channel.SimpleChannelInboundHandler')
+import { EventEmitter } from 'events'
+import { ServerOptions } from '../socket-io'
+import { ServerEvent } from '../socket-io/constants'
+import { TextWebSocketFrameHandlerAdapter } from './adapter'
 
-export abstract class TextWebSocketFrameHandlerAdapter {
-    private _Handler
-    constructor() {
-        let TextWebSocketFrameHandlerAdapterImpl = Java.extend(SimpleChannelInboundHandler, {
-            userEventTriggered: this.userEventTriggered.bind(this),
-            acceptInboundMessage: (msg: any) => {
-                return TextWebSocketFrameMatcher.match(msg)
-            },
-            channelRead0: this.channelRead0.bind(this),
-            exceptionCaught: this.exceptionCaught.bind(this)
-        })
-        this._Handler = new TextWebSocketFrameHandlerAdapterImpl()
+export class TextWebSocketFrameHandler extends TextWebSocketFrameHandlerAdapter {
+    private event: EventEmitter
+    constructor(options: ServerOptions) {
+        super()
+        this.event = options.event
     }
-    abstract userEventTriggered(ctx: any, evt: any)
-    abstract channelRead0(ctx: any, msg: any)
-    abstract exceptionCaught(ctx: any, cause: Error)
-    getHandler() {
-        return this._Handler
+    userEventTriggered(ctx: any, evt: any) {
+        if (evt == 'HANDSHAKE_COMPLETE') {
+            this.event.emit(ServerEvent.connect, ctx)
+        }
+    }
+    channelRead0(ctx: any, msg: any) {
+        this.event.emit(ServerEvent.message, ctx, msg)
+    }
+    exceptionCaught(ctx: any, cause: Error) {
+        this.event.emit(ServerEvent.error, ctx, cause)
     }
 }

packages/websocket/src/netty/websocket_detect.ts

@@ -1,5 +1,5 @@
 import { EventEmitter } from 'events'
-import { WebSocketHandlerAdapter } from "../netty"
+import { WebSocketHandlerAdapter } from "./adapter"
 import { ServerEvent } from '../socket-io/constants'
 
 export class WebSocketDetect extends WebSocketHandlerAdapter {
@@ -11,10 +11,6 @@ export class WebSocketDetect extends WebSocketHandlerAdapter {
     channelRead(ctx: any, channel: any) {
         this.event.emit(ServerEvent.detect, ctx, channel)
     }
-    channelUnregistered(ctx: any) {
-        this.event.emit(ServerEvent.disconnect, ctx, 'client disconnect')
-        ctx.fireChannelUnregistered()
-    }
     exceptionCaught(ctx: any, cause: Error) {
         this.event.emit(ServerEvent.error, ctx, cause)
     }

packages/websocket/src/netty/websocket_handler.ts

@@ -3,7 +3,7 @@ import { ServerEvent } from '../socket-io/constants'
 
 import { Keys } from './constants'
 import { HttpRequestHandler } from './httprequest'
-import { WebSocketHandlerAdapter } from "../netty"
+import { WebSocketHandlerAdapter } from "./adapter"
 import { TextWebSocketFrameHandler } from './text_websocket_frame'
 
 const CharsetUtil = Java.type('io.netty.util.CharsetUtil')
@@ -41,9 +41,16 @@ export class WebSocketHandler extends WebSocketHandlerAdapter {
         ctx.fireChannelRead(msg)
     }
 
+    channelInactive(ctx: any) {
+        console.debug('WebSocketHandler channelInactive ' + ctx)
+        this.options.event.emit(ServerEvent.disconnect, ctx, 'netty channelInactive')
+        super.channelInactive(ctx)
+    }
+
     channelUnregistered(ctx: any) {
-        this.options.event.emit(ServerEvent.disconnect, ctx, 'client disconnect')
-        ctx.fireChannelUnregistered()
+        console.debug('WebSocketHandler channelUnregistered ' + ctx)
+        this.options.event.emit(ServerEvent.disconnect, ctx, 'netty channelUnregistered')
+        super.channelUnregistered(ctx)
     }
 
     exceptionCaught(ctx: any, cause: Error) {

packages/websocket/src/server/client.ts

@@ -1,40 +0,0 @@
-import { EventEmitter } from 'events'
-import { SocketIO } from '../socket-io/interfaces'
-import { AttributeKeys } from './constants'
-
-const TextWebSocketFrame = Java.type('io.netty.handler.codec.http.websocketx.TextWebSocketFrame')
-
-export class NettyClient extends EventEmitter implements SocketIO.EngineSocket {
-    private _id: string
-    private channel: any
-
-    server: any
-    readyState: string
-    remoteAddress: string
-    upgraded: boolean
-    request: any
-    transport: any
-
-    constructor(server: any, channel: any) {
-        super()
-        this.server = server
-        this.readyState = 'open'
-        this.remoteAddress = channel.remoteAddress() + ''
-        this.upgraded = true
-        this.request = channel.attr(AttributeKeys.Request).get()
-        this.transport = null
-
-        this.channel = channel
-        this._id = channel.id() + ''
-    }
-
-    get id() {
-        return this._id
-    }
-    send(text: string) {
-        this.channel.writeAndFlush(new TextWebSocketFrame(text))
-    }
-    close() {
-        this.channel.close()
-    }
-}

packages/websocket/src/server/httprequest.ts

@@ -1,61 +0,0 @@
-import { HttpRequestHandlerAdapter } from '../netty'
-import { AttributeKeys } from './constants'
-import { ServerOptions } from 'socket-io'
-
-const DefaultHttpResponse = Java.type('io.netty.handler.codec.http.DefaultHttpResponse')
-const DefaultFullHttpResponse = Java.type('io.netty.handler.codec.http.DefaultFullHttpResponse')
-const HttpHeaders = Java.type('io.netty.handler.codec.http.HttpHeaders')
-const HttpVersion = Java.type('io.netty.handler.codec.http.HttpVersion')
-const HttpResponseStatus = Java.type('io.netty.handler.codec.http.HttpResponseStatus')
-const LastHttpContent = Java.type('io.netty.handler.codec.http.LastHttpContent')
-
-const File = Java.type('java.io.File')
-const Runnable = Java.type('java.lang.Runnable')
-const RandomAccessFile = Java.type('java.io.RandomAccessFile')
-const DefaultFileRegion = Java.type('io.netty.channel.DefaultFileRegion')
-const ChannelFutureListener = Java.type('io.netty.channel.ChannelFutureListener')
-
-export class HttpRequestHandler extends HttpRequestHandlerAdapter {
-    private ws: string;
-    private root: string;
-    constructor(options: ServerOptions) {
-        super()
-        this.root = options.root;
-        this.ws = options.path;
-    }
-    channelRead0(ctx: any, request: any) {
-        if (request.getUri().startsWith(this.ws)) {
-            ctx.channel().attr(AttributeKeys.Request).set(request);
-            ctx.fireChannelRead(request.retain())
-        } else {
-            ctx.executor().execute(new Runnable({
-                run: () => {
-                    if (HttpHeaders.is100ContinueExpected(request)) {
-                        ctx.writeAndFlush(new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.CONTINUE))
-                    }
-                    let filename = request.getUri().split('?')[0].substr(1)
-                    let file = new File(this.root, filename || 'index.html')
-                    if (!file.exists() || !file.isFile()) {
-                        ctx.write(new DefaultHttpResponse(request.getProtocolVersion(), HttpResponseStatus.NOT_FOUND))
-                        ctx.writeAndFlush(LastHttpContent.EMPTY_LAST_CONTENT).addListener(ChannelFutureListener.CLOSE)
-                        return
-                    }
-                    let response = new DefaultHttpResponse(request.getProtocolVersion(), HttpResponseStatus.OK)
-                    response.headers().set(HttpHeaders.Names.CONTENT_TYPE, "text/html charset=UTF-8")
-                    let raf = new RandomAccessFile(file, 'r')
-                    let keepAlive = HttpHeaders.isKeepAlive(request)
-                    if (keepAlive) {
-                        response.headers().set(HttpHeaders.Names.CONTENT_LENGTH, file.length())
-                        response.headers().set(HttpHeaders.Names.CONNECTION, HttpHeaders.Values.KEEP_ALIVE)
-                    }
-                    ctx.write(response)
-                    ctx.write(new DefaultFileRegion(raf.getChannel(), 0, raf.length()))
-                    let future = ctx.writeAndFlush(LastHttpContent.EMPTY_LAST_CONTENT)
-                    if (!keepAlive) {
-                        future.addListener(ChannelFutureListener.CLOSE)
-                    }
-                }
-            }))
-        }
-    }
-}

packages/websocket/src/server/index.ts

@@ -1,70 +0,0 @@
-import { EventEmitter } from 'events'
-
-import { ServerOptions } from '../socket-io'
-import { ServerEvent } from '../socket-io/constants'
-
-import { NettyClient } from './client'
-import { Keys } from './constants'
-import { WebSocketDetect } from './websocket_detect'
-import { WebSocketHandler } from './websocket_handler'
-
-class NettyWebSocketServer extends EventEmitter {
-    private pipeline: any
-    private clients: Map<string, NettyClient>
-
-    constructor(pipeline: any, options: ServerOptions) {
-        super()
-        this.clients = new Map()
-        this.pipeline = pipeline
-        let connectEvent = options.event
-        try { this.pipeline.remove(Keys.Detect) } catch (error) { }
-        this.pipeline.addFirst(Keys.Detect, new WebSocketDetect(connectEvent).getHandler())
-        connectEvent.on(ServerEvent.detect, (ctx, channel) => {
-            channel.pipeline().addFirst(Keys.Handler, new WebSocketHandler(options).getHandler())
-            ctx.fireChannelRead(channel)
-        })
-        connectEvent.on(ServerEvent.connect, (ctx) => {
-            let cid = ctx?.channel().id() + ''
-            let nettyClient = new NettyClient(this, ctx.channel())
-            this.clients.set(cid, nettyClient)
-            this.emit(ServerEvent.connect, nettyClient)
-        })
-        connectEvent.on(ServerEvent.message, (ctx, msg) => {
-            let cid = ctx?.channel().id() + ''
-            if (this.clients.has(cid)) {
-                this.emit(ServerEvent.message, this.clients.get(cid), msg.text())
-            } else {
-                console.error(`unknow client ${ctx} reciver message ${msg.text()}`)
-            }
-        })
-        connectEvent.on(ServerEvent.disconnect, (ctx, cause) => {
-            let cid = ctx?.channel().id() + ''
-            if (this.clients.has(cid)) {
-                this.emit(ServerEvent.disconnect, this.clients.get(cid), cause)
-            } else {
-                console.error(`unknow client ${ctx} disconnect cause ${cause}`)
-            }
-        })
-        connectEvent.on(ServerEvent.error, (ctx, cause) => {
-            let cid = ctx?.channel().id() + ''
-            if (this.clients.has(cid)) {
-                this.emit(ServerEvent.error, this.clients.get(cid), cause)
-            } else {
-                console.error(`unknow client ${ctx} cause error ${cause}`)
-                console.ex(cause)
-            }
-        })
-    }
-    close() {
-        if (this.pipeline.names().contains(Keys.Detect)) {
-            this.pipeline.remove(Keys.Detect)
-        }
-        this.clients.forEach(client => client.close())
-    }
-}
-
-export {
-    NettyWebSocketServer,
-    ServerEvent,
-    NettyClient
-}

packages/websocket/src/server/text_websocket_frame.ts

@@ -1,23 +0,0 @@
-import { EventEmitter } from 'events'
-import { ServerOptions } from '../socket-io';
-import { ServerEvent } from '../socket-io/constants'
-import { TextWebSocketFrameHandlerAdapter } from '../netty'
-
-export class TextWebSocketFrameHandler extends TextWebSocketFrameHandlerAdapter {
-    private event: EventEmitter;
-    constructor(options: ServerOptions) {
-        super()
-        this.event = options.event;
-    }
-    userEventTriggered(ctx: any, evt: any) {
-        if (evt == 'HANDSHAKE_COMPLETE') {
-            this.event.emit(ServerEvent.connect, ctx)
-        }
-    }
-    channelRead0(ctx: any, msg: any) {
-        this.event.emit(ServerEvent.message, ctx, msg)
-    }
-    exceptionCaught(ctx: any, cause: Error) {
-        this.event.emit(ServerEvent.error, ctx, cause)
-    }
-}

packages/websocket/src/socket-io/adapter.ts

@@ -1,24 +1,39 @@
 import { EventEmitter } from 'events'
-import { SocketIO } from './interfaces';
-import { Namespace } from './namespace';
-import { Parser } from './parser';
-import { Socket } from './socket';
+import { Namespace } from './namespace'
+import { Parser } from './parser'
+import { Socket } from './socket'
 
-export class Adapter extends EventEmitter implements SocketIO.Adapter {
-    nsp: Namespace;
-    rooms: Rooms;
-    sids: { [id: string]: { [room: string]: boolean; }; };
+export type SocketId = string
+export type Room = string
+
+export interface BroadcastFlags {
+    volatile?: boolean
+    compress?: boolean
+    local?: boolean
+    broadcast?: boolean
+    binary?: boolean
+}
+
+export interface BroadcastOptions {
+    rooms: Set<Room>
+    except?: Set<SocketId>
+    flags?: BroadcastFlags
+}
+
+export class Adapter extends EventEmitter implements Adapter {
+    rooms: Map<Room, Set<SocketId>>
+    sids: Map<SocketId, Set<Room>>
+    private readonly encoder: Parser
     parser: Parser
-    constructor(nsp: Namespace) {
+
+    constructor(readonly nsp: Namespace) {
         super()
-        this.nsp = nsp;
-        this.rooms = new Rooms();
-        this.sids = {};
-        this.parser = nsp.server.parser;
-    }
-    add(id: string, room: string, callback?: (err?: any) => void): void {
-        return this.addAll(id, [room], callback);
+        this.rooms = new Map()
+        this.sids = new Map()
+        this.parser = nsp.server._parser
+        this.encoder = this.parser
     }
+
     /**
      * Adds a socket to a list of room.
      *
@@ -27,101 +42,123 @@ export class Adapter extends EventEmitter implements SocketIO.Adapter {
      * @param {Function} callback
      * @api public
      */
-    addAll(id: string, rooms: string | any[], fn: { (err?: any): void; bind?: any; }) {
-        for (var i = 0; i < rooms.length; i++) {
-            var room = rooms[i];
-            this.sids[id] = this.sids[id] || {};
-            this.sids[id][room] = true;
-            this.rooms[room] = this.rooms[room] || new Room();
-            this.rooms[room].add(id);
-        }
-        fn && fn.bind(null, null)
-    };
-    del(id: string, room: string, callback?: (err?: any) => void): void {
-        if (this.sids[id]) delete this.sids[id][room];
+    addAll(id: SocketId, rooms: Set<Room>): Promise<void> | void {
+        for (const room of rooms) {
+            if (!this.sids.has(id)) {
+                this.sids.set(id, new Set())
+            }
+            this.sids.get(id).add(room)
 
-        if (this.rooms.hasOwnProperty(room)) {
-            this.rooms[room].del(id);
-            if (this.rooms[room].length === 0) delete this.rooms[room];
+            if (!this.rooms.has(room)) {
+                this.rooms.set(room, new Set())
+            }
+            this.rooms.get(room).add(id)
+        }
+    }
+    del(id: string, room: string, callback?: (err?: any) => void): void {
+        if (this.sids.has(id)) {
+            this.sids.get(id).delete(room)
+        }
+
+        if (this.rooms.has(room)) {
+            this.rooms.get(room).delete(id)
+            if (this.rooms.get(room).size === 0) this.rooms.delete(room)
         }
         callback && callback.bind(null, null)
     }
     delAll(id: string): void {
-        var rooms = this.sids[id];
-        if (rooms) {
-            for (var room in rooms) {
-                if (this.rooms.hasOwnProperty(room)) {
-                    this.rooms[room].del(id);
-                    if (this.rooms[room].length === 0) delete this.rooms[room];
-                }
+        if (!this.sids.has(id)) {
+            return
+        }
+
+        for (const room of this.sids.get(id)) {
+            if (this.rooms.has(room)) {
+                this.rooms.get(room).delete(id)
+                if (this.rooms.get(room).size === 0) this.rooms.delete(room)
             }
         }
-        delete this.sids[id];
+
+        this.sids.delete(id)
     }
-    broadcast(packet: any, opts: { rooms?: string[]; except?: string[]; flags?: { [flag: string]: boolean; }; }): void {
-        var rooms = opts.rooms || [];
-        var except = opts.except || [];
-        var flags = opts.flags || {};
-        var packetOpts = {
+
+    /**
+     * Broadcasts a packet.
+     *
+     * Options:
+     *  - `flags` {Object} flags for this packet
+     *  - `except` {Array} sids that should be excluded
+     *  - `rooms` {Array} list of rooms to broadcast to
+     *
+     * @param {Object} packet   the packet object
+     * @param {Object} opts     the options
+     * @public
+     */
+    public broadcast(packet: any, opts: BroadcastOptions): void {
+        const rooms = opts.rooms
+        const except = opts.except || new Set()
+        const flags = opts.flags || {}
+        const packetOpts = {
             preEncoded: true,
             volatile: flags.volatile,
             compress: flags.compress
-        };
-        var ids = {};
-        var self = this;
-        var socket: Socket;
+        }
+        const ids = new Set()
 
-        packet.nsp = this.nsp.name;
-        let encodedPackets = this.parser.encode(packet)
-        if (rooms.length) {
-            for (var i = 0; i < rooms.length; i++) {
-                var room = self.rooms[rooms[i]];
-                if (!room) continue;
-                var sockets = room.sockets;
-                for (var id in sockets) {
-                    if (sockets.hasOwnProperty(id)) {
-                        if (ids[id] || ~except.indexOf(id)) continue;
-                        socket = self.nsp.connected[id];
-                        if (socket) {
-                            socket.packet(encodedPackets as any, packetOpts);
-                            ids[id] = true;
-                        }
+        packet.nsp = this.nsp.name
+        const encodedPackets = this.encoder.encode(packet)
+
+        if (rooms.size) {
+            for (const room of rooms) {
+                if (!this.rooms.has(room)) continue
+
+                for (const id of this.rooms.get(room)) {
+                    if (ids.has(id) || except.has(id)) continue
+                    const socket = this.nsp.sockets.get(id)
+                    if (socket) {
+                        socket.packet(encodedPackets as any, packetOpts)
+                        ids.add(id)
                     }
                 }
             }
         } else {
-            for (var id in self.sids) {
-                if (self.sids.hasOwnProperty(id)) {
-                    if (~except.indexOf(id)) continue;
-                    socket = self.nsp.connected[id];
-                    if (socket) socket.packet(encodedPackets as any, packetOpts);
-                }
+            for (const [id] of this.sids) {
+                if (except.has(id)) continue
+                const socket = this.nsp.sockets.get(id)
+                if (socket) socket.packet(encodedPackets as any, packetOpts)
             }
         }
     }
-}
 
-class Rooms implements SocketIO.Rooms {
-    [room: string]: Room;
-}
+    /**
+     * Gets a list of sockets by sid.
+     *
+     * @param {Set<Room>} rooms   the explicit set of rooms to check.
+     */
+    public sockets(rooms: Set<Room>): Promise<Set<SocketId>> {
+        const sids = new Set<SocketId>()
+        if (rooms.size) {
+            for (const room of rooms) {
+                if (!this.rooms.has(room)) continue
+                for (const id of this.rooms.get(room)) {
+                    if (this.nsp.sockets.has(id)) {
+                        sids.add(id)
+                    }
+                }
+            }
+        } else {
+            for (const [id] of this.sids) {
+                if (this.nsp.sockets.has(id)) sids.add(id)
+            }
+        }
+        return Promise.resolve(sids)
+    }
 
-class Room implements SocketIO.Room {
-    sockets: { [id: string]: boolean; };
-    length: number;
-    constructor() {
-        this.sockets = {};
-        this.length = 0;
+    /**
+     * Gets the list of rooms a given socket has joined.
+     *
+     * @param {SocketId} id   the socket id
+     */
+    public socketRooms(id: SocketId): Set<Room> | undefined {
+        return this.sids.get(id)
     }
-    add(id) {
-        if (!this.sockets.hasOwnProperty(id)) {
-            this.sockets[id] = true;
-            this.length++;
-        }
-    }
-    del(id) {
-        if (this.sockets.hasOwnProperty(id)) {
-            delete this.sockets[id];
-            this.length--;
-        }
-    }
-}
+}

packages/websocket/src/socket-io/client.ts

@@ -1,107 +1,360 @@
 import { EventEmitter } from 'events'
 import { Parser } from './parser'
-import { Packet } from './packet';
-import { SocketIO } from './interfaces'
-import { Server, Socket } from './index';
-import { PacketTypes, SubPacketTypes } from './types';
-import { ServerEvent } from './constants';
+import { Packet } from './packet'
+import { Namespace, Server, Socket } from './index'
+import { PacketTypes, SubPacketTypes } from './types'
+import { ServerEvent } from './constants'
+import { SocketId } from './adapter'
+import { Transport } from '../transport'
 
-const parser = new Parser();
+const parser = new Parser()
 
-export class Client extends EventEmitter implements SocketIO.Client {
-    id: string;
-    server: Server;
-    conn: SocketIO.EngineSocket;
-    request: any;
-    sockets: { [id: string]: Socket; };
-    nsps: { [nsp: string]: SocketIO.Socket; };
-    connectBuffer: any;
+export class Client extends EventEmitter {
+    public readonly conn: Transport
+    /**
+     * @private
+     */
+    readonly id: string
+    private readonly server: Server
+    // private readonly encoder: Encoder
+    private readonly decoder: any
+    private sockets: Map<SocketId, Socket>
+    private nsps: Map<string, Socket>
+    private connectTimeout: NodeJS.Timeout
 
-    constructor(server: Server, engine: SocketIO.EngineSocket) {
-        super();
-        this.server = server;
-        this.conn = engine;
-        this.id = this.conn.id + '';
-        this.request = engine.request;
-        this.sockets = {};
-        this.nsps = {};
+    private checkIntervalTimer: NodeJS.Timeout
+    private upgradeTimeoutTimer: NodeJS.Timeout
+    private pingTimeoutTimer: NodeJS.Timeout
+    private pingIntervalTimer: NodeJS.Timeout
 
+    constructor(server: Server, conn) {
+        super()
+        this.server = server
+        this.conn = conn
+        // this.encoder = server.encoder
+        this.decoder = server._parser
+        this.id = this.conn.id + ''
+        this.setup()
+        // =============================
+        this.sockets = new Map()
+        this.nsps = new Map()
+        // ================== engine.io
+        this.onOpen()
+        // ================== Transport
         this.conn.on(ServerEvent.disconnect, (reason) => {
             this.onclose(reason)
         })
     }
-    connect(name, query) {
-        if (this.server.nsps[name]) {
-            // console.debug(`connecting to namespace ${name}`);
-            return this.doConnect(name, query);
-        }
-        this.server.checkNamespace(name, query, (dynamicNsp) => {
-            if (dynamicNsp) {
-                // console.debug('dynamic namespace %s was created', dynamicNsp.name);
-                this.doConnect(name, query);
+    /**
+     * @return the reference to the request that originated the Engine.IO connection
+     *
+     * @public
+     */
+    public get request(): any /**IncomingMessage */ {
+        return this.conn.request
+    }
+    /**
+     * Sets up event listeners.
+     *
+     * @private
+     */
+    private setup() {
+        // @ts-ignore
+        // this.decoder.on("decoded", this.ondecoded)
+        this.conn.on("data", this.ondata.bind(this))
+        this.conn.on("error", this.onerror.bind(this))
+        this.conn.on("close", this.onclose.bind(this))
+        console.debug(`setup client ${this.id}`)
+        this.connectTimeout = setTimeout(() => {
+            if (this.nsps.size === 0) {
+                console.debug("no namespace joined yet, close the client")
+                this.close()
             } else {
-                // console.debug('creation of namespace %s was denied', name);
-                this.packet({
+                console.debug("the client has already joined a namespace, nothing to do")
+            }
+        }, this.server._connectTimeout)
+    }
+    /**
+     * Connects a client to a namespace.
+     *
+     * @param {String} name - the namespace
+     * @param {Object} auth - the auth parameters
+     * @private
+     */
+    private connect(name: string, auth: object = {}) {
+        console.debug(`client ${this.id} connecting to namespace ${name} has: ${this.server._nsps.has(name)}`)
+        if (this.server._nsps.has(name)) {
+            return this.doConnect(name, auth)
+        }
+
+        this.server._checkNamespace(name, auth, (dynamicNsp: Namespace) => {
+            if (dynamicNsp) {
+                console.debug(`dynamic namespace ${dynamicNsp.name} was created`)
+                this.doConnect(name, auth)
+            } else {
+                console.debug(`creation of namespace ${name} was denied`)
+                this._packet({
                     type: PacketTypes.MESSAGE,
                     sub_type: SubPacketTypes.ERROR,
                     nsp: name,
-                    data: 'Invalid namespace'
-                });
+                    data: {
+                        message: "Invalid namespace"
+                    }
+                })
             }
         })
     }
-    doConnect(name, query) {
-        var nsp = this.server.of(name);
-        if ('/' != name && !this.nsps['/']) {
-            this.connectBuffer.push(name);
-            return;
+    doConnect(name, auth: object) {
+        if (this.connectTimeout) {
+            clearTimeout(this.connectTimeout)
+            this.connectTimeout = null
         }
-        var socket = nsp.add(this, query, () => {
-            this.sockets[socket.id] = socket;
-            this.nsps[nsp.name] = socket;
+        const nsp = this.server.of(name)
 
-            if ('/' == nsp.name && this.connectBuffer.length > 0) {
-                this.connectBuffer.forEach(this.connect, this);
-                this.connectBuffer = [];
-            }
-        });
+        nsp._add(this, auth, (socket: Socket) => {
+            this.sockets.set(socket.id, socket)
+            this.nsps.set(nsp.name, socket)
+        })
     }
-    packet(packet: Packet, opts: any = { preEncoded: false }) {
-        this.conn.send(opts.preEncoded ? packet as unknown as string : parser.encode(packet))
+    /**
+     * Disconnects from all namespaces and closes transport.
+     *
+     * @private
+     */
+    _disconnect() {
+        for (const socket of this.sockets.values()) {
+            socket.disconnect()
+        }
+        this.sockets.clear()
+        this.close()
+    }
+    /**
+     * Removes a socket. Called by each `Socket`.
+     *
+     * @private
+     */
+    _remove(socket: Socket) {
+        if (this.sockets.has(socket.id)) {
+            this.sockets.delete(socket.id)
+            this.nsps.delete(socket.nsp.name)
+        } else {
+            console.debug(`ignoring remove for ${socket.id}`,)
+        }
+        process.nextTick(() => {
+            if (this.sockets.size == 0) {
+                this.onclose('no live socket')
+            }
+        })
+    }
+    /**
+     * Closes the underlying connection.
+     *
+     * @private
+     */
+    private close() {
+        console.debug(`client ${this.id} close`)
+        if ("open" == this.conn.readyState) {
+            console.debug("forcing transport close")
+            this.onclose("forced server close")
+            this.conn.close()
+        }
+    }
+    /**
+     * Writes a packet to the transport.
+     *
+     * @param {Object} packet object
+     * @param {Object} opts
+     * @private
+     */
+    _packet(packet: Packet, opts = { preEncoded: false }) {
+        // opts = opts || {}
+        // const self = this
+
+        // // this writes to the actual connection
+        // function writeToEngine(encodedPackets) {
+        //     if (opts.volatile && !self.conn.transport.writable) return
+        //     for (let i = 0; i < encodedPackets.length; i++) {
+        //         self.conn.write(encodedPackets[i], { compress: opts.compress })
+        //     }
+        // }
+
+        // if ("open" == this.conn.readyState) {
+        //     debug("writing packet %j", packet)
+        //     if (!opts.preEncoded) {
+        //         // not broadcasting, need to encode
+        //         writeToEngine(this.encoder.encode(packet)) // encode, then write results to engine
+        //     } else {
+        //         // a broadcast pre-encodes a packet
+        //         writeToEngine(packet)
+        //     }
+        // } else {
+        //     debug("ignoring packet write %j", packet)
+        // }
+        if ("open" == this.conn.readyState) {
+            this.conn.send(opts.preEncoded ? packet as unknown as string : parser.encode(packet))
+        } else {
+            console.debug(`ignoring write packet ${JSON.stringify(packet)} to client ${this.id} is already close!`)
+        }
+    }
+    /**
+     * Called with incoming transport data.
+     *
+     * @private
+     */
+    private ondata(data) {
+        // try/catch is needed for protocol violations (GH-1880)
+        try {
+            this.decoder.add(data)
+        } catch (e) {
+            this.onerror(e)
+        }
+    }
+    /**
+     * Called when parser fully decodes a packet.
+     *
+     * @private
+     */
+    ondecoded(packet: Packet) {
+        if (SubPacketTypes.CONNECT == packet.sub_type) {
+            this.connect(packet.nsp, packet.data)
+        } else {
+            process.nextTick(() => {
+                const socket = this.nsps.get(packet.nsp)
+                if (socket) {
+                    socket._onpacket(packet)
+                } else {
+                    console.debug(`client ${this.id} no socket for namespace ${packet.nsp}.`)
+                }
+            })
+        }
+    }
+    /**
+     * Handles an error.
+     *
+     * @param {Object} err object
+     * @private
+     */
+    private onerror(err) {
+        for (const socket of this.sockets.values()) {
+            socket._onerror(err)
+        }
+        this.conn.close()
     }
     onclose(reason?: string) {
-        // debug('client close with reason %s', reason);
-        // ignore a potential subsequent `close` event
-        this.destroy();
-        // `nsps` and `sockets` are cleaned up seamlessly
-        for (var id in this.sockets) {
-            if (this.sockets.hasOwnProperty(id)) {
-                this.sockets[id].onclose(reason);
-            }
+        this.conn.readyState = "closing"
+        // ======= engine.io
+        this.onClose(reason)
+        // cleanup connectTimeout
+        if (this.connectTimeout) {
+            clearTimeout(this.connectTimeout)
+            this.connectTimeout = null
         }
-        this.sockets = {};
+        console.debug(`client ${this.id} close with reason ${reason}`)
+        // ignore a potential subsequent `close` event
+        // `nsps` and `sockets` are cleaned up seamlessly
+        for (const socket of this.sockets.values()) {
+            socket._onclose(reason)
+        }
+        this.sockets.clear()
         // this.decoder.destroy(); // clean up decoder
     }
-    disconnect() {
-        if ('open' == this.conn.readyState) {
-            // debug('forcing transport close');
-            this.conn.close();
-            this.onclose('forced server close');
-        }
-    }
-    remove(socket: Socket) {
-        if (this.sockets.hasOwnProperty(socket.id)) {
-            var nsp = this.sockets[socket.id].nsp.name;
-            delete this.sockets[socket.id];
-            delete this.nsps[nsp];
-        } else {
-            // debug('ignoring remove for %s', socket.id);
-        }
-    }
+
     destroy() {
         // this.conn.removeListener('data', this.ondata);
         // this.conn.removeListener('error', this.onerror);
         // this.conn.removeListener('close', this.onclose);
         // this.decoder.removeListener('decoded', this.ondecoded);
-    };
+    }
+
+    //================== engine.io
+    onOpen() {
+        this.conn.readyState = "open"
+        this._packet({
+            type: PacketTypes.OPEN,
+            data: {
+                sid: this.id,
+                upgrades: [],
+                pingInterval: this.server.options.pingInterval,
+                pingTimeout: this.server.options.pingTimeout
+            }
+        })
+        this.schedulePing()
+    }
+
+    onPacket(packet: Packet) {
+        if ("open" === this.conn.readyState) {
+            // export packet event
+            // debug("packet")
+            // this.emit("packet", packet)
+
+            // Reset ping timeout on any packet, incoming data is a good sign of
+            // other side's liveness
+            this.resetPingTimeout(this.server.options.pingInterval + this.server.options.pingTimeout * 2)
+            switch (packet.type) {
+                case PacketTypes.PING:
+                    this._packet({
+                        type: PacketTypes.PONG,
+                        data: packet.data
+                    })
+                    break
+                case PacketTypes.PONG:
+                    this.schedulePing()
+                    break
+                case PacketTypes.UPGRADE:
+                    break
+                case PacketTypes.MESSAGE:
+                    this.ondecoded(packet)
+                    break
+                case PacketTypes.CLOSE:
+                    this.onclose()
+                    break
+                default:
+                    console.log(`client ${this.id} reciver unknow packet type: ${packet.type}`)
+            }
+        } else {
+            console.debug(`packet received with closed client ${this.id}`)
+        }
+    }
+    /**
+     * Called upon transport considered closed.
+     * Possible reasons: `ping timeout`, `client error`, `parse error`,
+     * `transport error`, `server close`, `transport close`
+     */
+    onClose(reason, description?: string) {
+        // if ("closed" !== this.conn.readyState) {
+        clearTimeout(this.pingIntervalTimer)
+        clearTimeout(this.pingTimeoutTimer)
+
+        clearInterval(this.checkIntervalTimer)
+        this.checkIntervalTimer = null
+        clearTimeout(this.upgradeTimeoutTimer)
+        //     this.emit("close", reason, description)
+        // }
+    }
+    /**
+     * Pings client every `this.pingInterval` and expects response
+     * within `this.pingTimeout` or closes connection.
+     *
+     * @api private
+     */
+    schedulePing() {
+        clearTimeout(this.pingIntervalTimer)
+        this.pingIntervalTimer = setTimeout(() => {
+            this.resetPingTimeout(this.server.options.pingTimeout)
+            process.nextTick(() => this._packet({ type: PacketTypes.PING }))
+        }, this.server.options.pingInterval)
+    }
+
+    /**
+     * Resets ping timeout.
+     *
+     * @api private
+     */
+    resetPingTimeout(timeout: number) {
+        clearTimeout(this.pingTimeoutTimer)
+        this.pingTimeoutTimer = setTimeout(() => {
+            if (this.conn.readyState === "closed") return
+            this.onclose("ping timeout")
+        }, timeout)
+    }
 }

packages/websocket/src/socket-io/constants.ts

@@ -4,5 +4,6 @@ export enum ServerEvent {
     connection = 'connection',
     message = 'message',
     error = 'error',
-    disconnect = 'disconnect'
-}
+    disconnecting = 'disconnecting',
+    disconnect = 'disconnect',
+}

packages/websocket/src/socket-io/index.ts

@@ -3,232 +3,673 @@ import { EventEmitter } from 'events'
 import { ServerEvent } from './constants'
 import { Namespace } from './namespace'
 import { Client } from './client'
-import { SocketIO } from './interfaces'
 import { Parser } from './parser'
 import { PacketTypes, SubPacketTypes } from './types'
 import { Packet } from './packet'
 import { Socket } from './socket'
 import { Adapter } from './adapter'
+import { Transport } from '../transport'
+import { ParentNamespace } from './parent-namespace'
 
-interface ServerOptions extends SocketIO.ServerOptions {
+interface EngineOptions {
+    /**
+     * how many ms without a pong packet to consider the connection closed
+     * @default 5000
+     */
+    pingTimeout: number
+    /**
+     * how many ms before sending a new ping packet
+     * @default 25000
+     */
+    pingInterval: number
+    /**
+     * how many ms before an uncompleted transport upgrade is cancelled
+     * @default 10000
+     */
+    upgradeTimeout: number
+    /**
+     * how many bytes or characters a message can be, before closing the session (to avoid DoS).
+     * @default 1e5 (100 KB)
+     */
+    maxHttpBufferSize: number
+    /**
+     * A function that receives a given handshake or upgrade request as its first parameter,
+     * and can decide whether to continue or not. The second argument is a function that needs
+     * to be called with the decided information: fn(err, success), where success is a boolean
+     * value where false means that the request is rejected, and err is an error code.
+     */
+    // allowRequest: (
+    //     req: http.IncomingMessage,
+    //     fn: (err: string | null | undefined, success: boolean) => void
+    // ) => void
+    /**
+     * the low-level transports that are enabled
+     * @default ["polling", "websocket"]
+     */
+    // transports: Transport[]
+    /**
+     * whether to allow transport upgrades
+     * @default true
+     */
+    allowUpgrades: boolean
+    /**
+     * parameters of the WebSocket permessage-deflate extension (see ws module api docs). Set to false to disable.
+     * @default false
+     */
+    perMessageDeflate: boolean | object
+    /**
+     * parameters of the http compression for the polling transports (see zlib api docs). Set to false to disable.
+     * @default true
+     */
+    httpCompression: boolean | object
+    /**
+     * what WebSocket server implementation to use. Specified module must
+     * conform to the ws interface (see ws module api docs). Default value is ws.
+     * An alternative c++ addon is also available by installing uws module.
+     */
+    wsEngine: string
+    /**
+     * an optional packet which will be concatenated to the handshake packet emitted by Engine.IO.
+     */
+    initialPacket: any
+    /**
+     * configuration of the cookie that contains the client sid to send as part of handshake response headers. This cookie
+     * might be used for sticky-session. Defaults to not sending any cookie.
+     * @default false
+     */
+    // cookie: CookieSerializeOptions | boolean
+    /**
+     * the options that will be forwarded to the cors module
+     */
+    // cors: CorsOptions
+}
+
+interface AttachOptions {
+    /**
+     * name of the path to capture
+     * @default "/engine.io"
+     */
+    path: string
+    /**
+     * destroy unhandled upgrade requests
+     * @default true
+     */
+    destroyUpgrade: boolean
+    /**
+     * milliseconds after which unhandled requests are ended
+     * @default 1000
+     */
+    destroyUpgradeTimeout: number
+}
+
+interface EngineAttachOptions extends EngineOptions, AttachOptions { }
+
+interface ServerOptions extends EngineAttachOptions {
     event?: EventEmitter
     root?: string
+    /**
+     * name of the path to capture
+     * @default "/socket.io"
+     */
+    path: string
+    /**
+     * whether to serve the client files
+     * @default true
+     */
+    serveClient: boolean
+    /**
+     * the adapter to use
+     * @default the in-memory adapter (https://github.com/socketio/socket.io-adapter)
+     */
+    adapter: any
+    /**
+     * the parser to use
+     * @default the default parser (https://github.com/socketio/socket.io-parser)
+     */
+    parser: any
+    /**
+     * how many ms before a client without namespace is closed
+     * @default 45000
+     */
+    connectTimeout: number
 }
 
 interface WebSocketServer extends EventEmitter {
     close(): void
 }
 
-class Server implements SocketIO.Server {
+class Server {
+    public readonly sockets: Namespace
+
+    /**
+     * @private
+     */
+    _parser: Parser
+    private readonly encoder
+
+    /**
+     * @private
+     */
+    _nsps: Map<string, Namespace>
+    private parentNsps: Map<
+        | string
+        | RegExp
+        | ((
+            name: string,
+            query: object,
+            fn: (err: Error, success: boolean) => void
+        ) => void),
+        ParentNamespace
+    > = new Map();
+    private _adapter: Adapter
+    // private _serveClient: boolean;
+    private eio
+    private engine: { ws: any }
+    private _path: string
+    private clientPathRegex: RegExp
+    /**
+     * @private
+     */
+    _connectTimeout: number
+
+    options: Partial<ServerOptions>
     private websocketServer: WebSocketServer
     private allClients: Map<string, Client>
 
-    engine: { ws: any }
-    nsps: { [namespace: string]: Namespace }
-    sockets: Namespace
-    json: SocketIO.Server
-    volatile: SocketIO.Server
-    local: SocketIO.Server
-    parser = new Parser();
-    _adapter: Adapter
-    options: ServerOptions
-
-    constructor(instance: any, options: ServerOptions) {
+    constructor(instance: any, options: Partial<ServerOptions>) {
         if (!instance) { throw new Error('instance can\'t be undefiend!') }
-        this.allClients = new Map()
-        this.nsps = {}
-        this.sockets = new Namespace('/', this)
-        this.nsps['/'] = this.sockets
-        if (instance.class.name.startsWith('io.netty.channel')) {
-            let { NettyWebSocketServer } = require("../server")
-            this.websocketServer = new NettyWebSocketServer(instance, Object.assign({
-                event: new EventEmitter(),
-                path: '/socket.io',
-                root: root + '/wwwroot'
-            }, options))
-        } else {
-            let { TomcatWebSocketServer } = require("../tomcat/server")
-            this.websocketServer = new TomcatWebSocketServer(instance, options)
-        }
+        this.options = Object.assign({
+            event: new EventEmitter(),
+            path: '/socket.io',
+            root: root + '/wwwroot',
+            serveClient: false,
+            connectTimeout: 45000,
+            wsEngine: process.env.EIO_WS_ENGINE || "ws",
+            pingTimeout: 5000,
+            pingInterval: 25000,
+            upgradeTimeout: 10000,
+            maxHttpBufferSize: 1e6,
+            transports: 'websocket',
+            allowUpgrades: true,
+            httpCompression: {
+                threshold: 1024
+            },
+            cors: false
+        }, options)
+        this.initServerConfig()
+        this.sockets = this.of('/')
+        this.selectServerImpl(instance)
         this.initServer()
     }
+    /**
+     * Sets/gets whether client code is being served.
+     *
+     * @param {Boolean} v - whether to serve client code
+     * @return {Server|Boolean} self when setting or value when getting
+     * @public
+     */
+    public serveClient(v: boolean): Server
+    public serveClient(): boolean
+    public serveClient(v?: boolean): Server | boolean {
+        throw new Error("Method not implemented.")
+    }
+    /**
+     * Executes the middleware for an incoming namespace not already created on the server.
+     *
+     * @param {String} name - name of incoming namespace
+     * @param {Object} auth - the auth parameters
+     * @param {Function} fn - callback
+     *
+     * @private
+     */
+    _checkNamespace(
+        name: string,
+        auth: object,
+        fn: (nsp: Namespace) => void
+    ) {
+        // if (this.parentNsps.size === 0) return fn(false)
 
-    checkRequest(req: any, fn: (err: any, success: boolean) => void): void {
-        throw new Error("Method not implemented.")
-    }
-    serveClient(): boolean
-    serveClient(v: boolean): SocketIO.Server
-    serveClient(v?: any): boolean | SocketIO.Server {
-        throw new Error("Method not implemented.")
+        // const keysIterator = this.parentNsps.keys()
+
+        // const run = () => {
+        //     let nextFn = keysIterator.next()
+        //     if (nextFn.done) {
+        //         return fn(false)
+        //     }
+        //     nextFn.value(name, auth, (err, allow) => {
+        //         if (err || !allow) {
+        //             run()
+        //         } else {
+        //             fn(this.parentNsps.get(nextFn.value).createChild(name))
+        //         }
+        //     })
+        // }
+        fn(undefined)
     }
+    /**
+     * Sets the client serving path.
+     *
+     * @param {String} v pathname
+     * @return {Server|String} self when setting or value when getting
+     * @public
+     */
     path(): string
-    path(v: string): SocketIO.Server
-    path(v?: any): string | SocketIO.Server {
-        if (!arguments.length) return this.options.path
-        this.options.path = v.replace(/\/$/, '')
+    path(v: string): Server
+    path(v?: any): string | Server {
+        if (!arguments.length) return this._path
+
+        this._path = v.replace(/\/$/, "")
+
+        const escapedPath = this._path.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&")
+        this.clientPathRegex = new RegExp(
+            "^" +
+            escapedPath +
+            "/socket\\.io(\\.min|\\.msgpack\\.min)?\\.js(\\.map)?$"
+        )
         return this
     }
-    adapter(): Adapter
-    adapter(v: any): SocketIO.Server
-    adapter(v?: any): Adapter | SocketIO.Server {
+    /**
+     * Set the delay after which a client without namespace is closed
+     * @param v
+     * @public
+     */
+    public connectTimeout(v: number): Server
+    public connectTimeout(): number
+    public connectTimeout(v?: number): Server | number {
+        if (v === undefined) return this._connectTimeout
+        this._connectTimeout = v
+        return this
+    }
+    /**
+     * Sets the adapter for rooms.
+     *
+     * @param {Adapter} v pathname
+     * @return {Server|Adapter} self when setting or value when getting
+     * @public
+     */
+    public adapter(): any
+    public adapter(v: any)
+    public adapter(v?): Server | any {
         if (!arguments.length) return this._adapter
         this._adapter = v
-        for (var i in this.nsps) {
-            if (this.nsps.hasOwnProperty(i)) {
-                this.nsps[i].initAdapter()
-            }
+        for (const nsp of this._nsps.values()) {
+            nsp._initAdapter()
         }
         return this
     }
-    origins(): string | string[]
-    origins(v: string | string[]): SocketIO.Server
-    origins(fn: (origin: string, callback: (error: string, success: boolean) => void) => void): SocketIO.Server
-    origins(fn?: any): string | string[] | SocketIO.Server {
-        throw new Error("Method not implemented.")
-    }
-    attach(srv: any, opts?: SocketIO.ServerOptions): SocketIO.Server
-    attach(port: number, opts?: SocketIO.ServerOptions): SocketIO.Server
-    attach(port: any, opts?: any): SocketIO.Server {
-        throw new Error("Method not implemented.")
-    }
-    listen(srv: any, opts?: SocketIO.ServerOptions): SocketIO.Server
-    listen(port: number, opts?: SocketIO.ServerOptions): SocketIO.Server
-    listen(port: any, opts?: any): SocketIO.Server {
-        throw new Error("Method not implemented.")
-    }
-    bind(srv: any): SocketIO.Server {
-        throw new Error("Method not implemented.")
-    }
-    onconnection(client: Client): SocketIO.Server {
-        client.packet({
-            type: PacketTypes.OPEN,
-            data: {
-                sid: client.id,
-                upgrades: [],
-                pingInterval: 25000,
-                pingTimeout: 5000
-            }
-        })
-        this.sockets.add(client)
+    // /**
+    //  * Attaches socket.io to a server or port.
+    //  *
+    //  * @param {http.Server|Number} srv - server or port
+    //  * @param {Object} opts - options passed to engine.io
+    //  * @return {Server} self
+    //  * @public
+    //  */
+    // public listen(srv: http.Server, opts?: Partial<ServerOptions>): Server
+    // public listen(srv: number, opts?: Partial<ServerOptions>): Server
+    // public listen(srv: any, opts: Partial<ServerOptions> = {}): Server {
+    //     return this.attach(srv, opts)
+    // }
+
+    // /**
+    //  * Attaches socket.io to a server or port.
+    //  *
+    //  * @param {http.Server|Number} srv - server or port
+    //  * @param {Object} opts - options passed to engine.io
+    //  * @return {Server} self
+    //  * @public
+    //  */
+    // public attach(srv: http.Server, opts?: Partial<ServerOptions>): Server
+    // public attach(port: number, opts?: Partial<ServerOptions>): Server
+    // public attach(srv: any, opts: Partial<ServerOptions> = {}): Server {
+    //     if ("function" == typeof srv) {
+    //         const msg =
+    //             "You are trying to attach socket.io to an express " +
+    //             "request handler function. Please pass a http.Server instance."
+    //         throw new Error(msg)
+    //     }
+
+    //     // handle a port as a string
+    //     if (Number(srv) == srv) {
+    //         srv = Number(srv)
+    //     }
+
+    //     if ("number" == typeof srv) {
+    //         debug("creating http server and binding to %d", srv)
+    //         const port = srv
+    //         srv = http.createServer((req, res) => {
+    //             res.writeHead(404)
+    //             res.end()
+    //         })
+    //         srv.listen(port)
+    //     }
+
+    //     // set engine.io path to `/socket.io`
+    //     opts.path = opts.path || this._path
+
+    //     this.initEngine(srv, opts)
+
+    //     return this
+    // }
+    // /**
+    //  * Initialize engine
+    //  *
+    //  * @param srv - the server to attach to
+    //  * @param opts - options passed to engine.io
+    //  * @private
+    //  */
+    // private initEngine(srv: http.Server, opts: Partial<EngineAttachOptions>) {
+    //     // initialize engine
+    //     debug("creating engine.io instance with opts %j", opts)
+    //     this.eio = engine.attach(srv, opts)
+
+    //     // attach static file serving
+    //     if (this._serveClient) this.attachServe(srv)
+
+    //     // Export http server
+    //     this.httpServer = srv
+
+    //     // bind to engine events
+    //     this.bind(this.eio)
+    // }
+
+    // /**
+    //  * Attaches the static file serving.
+    //  *
+    //  * @param {Function|http.Server} srv http server
+    //  * @private
+    //  */
+    // private attachServe(srv) {
+    //     debug("attaching client serving req handler")
+
+    //     const evs = srv.listeners("request").slice(0)
+    //     srv.removeAllListeners("request")
+    //     srv.on("request", (req, res) => {
+    //         if (this.clientPathRegex.test(req.url)) {
+    //             this.serve(req, res)
+    //         } else {
+    //             for (let i = 0; i < evs.length; i++) {
+    //                 evs[i].call(srv, req, res)
+    //             }
+    //         }
+    //     })
+    // }
+    // /**
+    //  * Handles a request serving of client source and map
+    //  *
+    //  * @param {http.IncomingMessage} req
+    //  * @param {http.ServerResponse} res
+    //  * @private
+    //  */
+    // private serve(req: http.IncomingMessage, res: http.ServerResponse) {
+    //     const filename = req.url.replace(this._path, "")
+    //     const isMap = dotMapRegex.test(filename)
+    //     const type = isMap ? "map" : "source"
+
+    //     // Per the standard, ETags must be quoted:
+    //     // https://tools.ietf.org/html/rfc7232#section-2.3
+    //     const expectedEtag = '"' + clientVersion + '"'
+
+    //     const etag = req.headers["if-none-match"]
+    //     if (etag) {
+    //         if (expectedEtag == etag) {
+    //             debug("serve client %s 304", type)
+    //             res.writeHead(304)
+    //             res.end()
+    //             return
+    //         }
+    //     }
+
+    //     debug("serve client %s", type)
+
+    //     res.setHeader("Cache-Control", "public, max-age=0")
+    //     res.setHeader(
+    //         "Content-Type",
+    //         "application/" + (isMap ? "json" : "javascript")
+    //     )
+    //     res.setHeader("ETag", expectedEtag)
+
+    //     if (!isMap) {
+    //         res.setHeader("X-SourceMap", filename.substring(1) + ".map")
+    //     }
+    //     Server.sendFile(filename, req, res)
+    // }
+
+    // /**
+    //  * @param filename
+    //  * @param req
+    //  * @param res
+    //  * @private
+    //  */
+    // private static sendFile(
+    //     filename: string,
+    //     req: http.IncomingMessage,
+    //     res: http.ServerResponse
+    // ) {
+    //     const readStream = createReadStream(
+    //         path.join(__dirname, "../client-dist/", filename)
+    //     )
+    //     const encoding = accepts(req).encodings(["br", "gzip", "deflate"])
+
+    //     const onError = err => {
+    //         if (err) {
+    //             res.end()
+    //         }
+    //     }
+
+    //     switch (encoding) {
+    //         case "br":
+    //             res.writeHead(200, { "content-encoding": "br" })
+    //             readStream.pipe(createBrotliCompress()).pipe(res)
+    //             pipeline(readStream, createBrotliCompress(), res, onError)
+    //             break
+    //         case "gzip":
+    //             res.writeHead(200, { "content-encoding": "gzip" })
+    //             pipeline(readStream, createGzip(), res, onError)
+    //             break
+    //         case "deflate":
+    //             res.writeHead(200, { "content-encoding": "deflate" })
+    //             pipeline(readStream, createDeflate(), res, onError)
+    //             break
+    //         default:
+    //             res.writeHead(200)
+    //             pipeline(readStream, res, onError)
+    //     }
+    // }
+
+    // /**
+    //  * Binds socket.io to an engine.io instance.
+    //  *
+    //  * @param {engine.Server} engine engine.io (or compatible) server
+    //  * @return {Server} self
+    //  * @public
+    //  */
+    // public bind(engine): Server {
+    //     this.engine = engine
+    //     this.engine.on("connection", this.onconnection.bind(this))
+    //     return this
+    // }
+    /**
+     * Called with each incoming transport connection.
+     *
+     * @param {engine.Socket} conn
+     * @return {Server} self
+     * @private
+     */
+    private onconnection(conn): Server {
+        console.debug(`incoming connection with id ${conn.id}`)
+        let client = new Client(this, conn)
+        this.allClients.set(conn.id, client)
         return this
     }
-    of(nsp: string): Namespace {
-        if (!this.nsps[nsp]) {
-            this.nsps[nsp] = new Namespace(nsp, this)
+    // of(nsp: string): Namespace {
+    //     if (!this._nsps.has(nsp)) {
+    //         console.debug(`create Namespace ${nsp}`)
+    //         this._nsps.set(nsp, new Namespace(this, nsp))
+    //     }
+    //     return this._nsps.get(nsp)
+    // }
+    /**
+     * Looks up a namespace.
+     *
+     * @param {String|RegExp|Function} name nsp name
+     * @param {Function} [fn] optional, nsp `connection` ev handler
+     * @public
+     */
+    public of(
+        name:
+            | string
+            | RegExp
+            | ((
+                name: string,
+                query: object,
+                fn: (err: Error, success: boolean) => void
+            ) => void),
+        fn?: (socket: Socket) => void
+    ) {
+        if (typeof name === "function" || name instanceof RegExp) {
+            const parentNsp = new ParentNamespace(this)
+            console.debug(`initializing parent namespace ${parentNsp.name}`)
+            if (typeof name === "function") {
+                this.parentNsps.set(name, parentNsp)
+            } else {
+                this.parentNsps.set(
+                    (nsp, conn, next) => next(null, (name as RegExp).test(nsp)),
+                    parentNsp
+                )
+            }
+            if (fn) {
+                // @ts-ignore
+                parentNsp.on("connect", fn)
+            }
+            return parentNsp
         }
-        return this.nsps[nsp]
+        if (String(name)[0] !== "/") name = "/" + name
+        let nsp = this._nsps.get(name)
+        if (!nsp) {
+            console.debug(`initializing namespace ${name}`)
+            nsp = new Namespace(this, name)
+            this._nsps.set(name, nsp)
+        }
+        if (fn) nsp.on("connect", fn)
+        return nsp
     }
     close(fn?: () => void): void {
-        for (let socket in this.sockets.sockets) {
-            this.sockets.sockets[socket].onclose()
+        this.clients.length
+        for (const client of this.allClients.values()) {
+            client._disconnect()
         }
+
+        // this.engine.close()
         this.websocketServer.close()
+
+        // if (this.httpServer) {
+        //     this.httpServer.close(fn)
+        // } else {
+        fn && fn()
+        // }
     }
-    on(event: "connection", listener: (socket: SocketIO.Socket) => void): SocketIO.Namespace
-    on(event: "connect", listener: (socket: SocketIO.Socket) => void): SocketIO.Namespace
-    on(event: string, listener: Function): SocketIO.Namespace
-    on(event: any, listener: any): SocketIO.Namespace {
+    on(event: "connection", listener: (socket: Socket) => void): Namespace
+    on(event: "connect", listener: (socket: Socket) => void): Namespace
+    on(event: string, listener: Function): Namespace
+    on(event: any, listener: any): Namespace {
         return this.sockets.on(event, listener)
     }
-    to(room: string): SocketIO.Namespace {
+    to(room: string): Namespace {
         return this.sockets.to(room)
     }
-    in(room: string): SocketIO.Namespace {
+    in(room: string): Namespace {
         return this.sockets.in(room)
     }
-    use(fn: (socket: SocketIO.Socket, fn: (err?: any) => void) => void): SocketIO.Namespace {
+    use(fn: (socket: Socket, fn: (err?: any) => void) => void): Namespace {
         return this.sockets.use(fn)
     }
-    emit(event: string, ...args: any[]): SocketIO.Namespace {
+    emit(event: string, ...args: any[]): Namespace {
         // @ts-ignore
         return this.sockets.emit(event, ...args)
     }
-    send(...args: any[]): SocketIO.Namespace {
+    send(...args: any[]): Namespace {
         return this.sockets.send(...args)
     }
-    write(...args: any[]): SocketIO.Namespace {
+    write(...args: any[]): Namespace {
         return this.sockets.write(...args)
     }
-    clients(...args: any[]): SocketIO.Namespace {
+    clients(...args: any[]): Namespace {
         return this.sockets.clients(args[0])
     }
-    compress(...args: any[]): SocketIO.Namespace {
+    compress(...args: any[]): Namespace {
         return this.sockets.compress(args[0])
     }
     // ===============================
-    checkNamespace(name, query, fn) {
-        fn(false)
-    };
-
+    private initServerConfig() {
+        this.allClients = new Map()
+        this._nsps = new Map()
+        this.connectTimeout(this.options.connectTimeout || 45000)
+        this._parser = this.options.parser || new Parser()
+        this.adapter(this.options.adapter || Adapter)
+    }
+    private selectServerImpl(instance: any) {
+        let WebSocketServerImpl = undefined
+        if (instance.class.name.startsWith('io.netty.channel')) {
+            WebSocketServerImpl = require("../netty").NettyWebSocketServer
+        } else {
+            WebSocketServerImpl = require("../tomcat").TomcatWebSocketServer
+        }
+        this.websocketServer = new WebSocketServerImpl(instance, this.options)
+    }
     private initServer() {
-        this.websocketServer.on(ServerEvent.connect, (socket: SocketIO.EngineSocket) => {
-            let client = new Client(this, socket)
-            this.allClients.set(socket.id, client)
-            this.onconnection(client)
+        this.websocketServer.on(ServerEvent.connect, (transport: Transport) => {
+            this.onconnection(transport)
         })
-        this.websocketServer.on(ServerEvent.message, (socket: SocketIO.EngineSocket, text) => {
-            if (this.allClients.has(socket.id)) {
-                this.processPacket(this.parser.decode(text), this.allClients.get(socket.id))
+        this.websocketServer.on(ServerEvent.message, (transport: Transport, text) => {
+            if (this.allClients.has(transport.id)) {
+                let client = this.allClients.get(transport.id)
+                client.onPacket(this._parser.decode(text))
             } else {
-                console.error(`unknow engine socket ${socket.id} reciver message ${text}`)
+                console.error(`unknow transport ${transport.id} reciver message ${text}`)
             }
         })
-        this.websocketServer.on(ServerEvent.disconnect, (socket: SocketIO.EngineSocket, reason) => {
-            if (this.allClients.has(socket.id)) {
-                this.allClients.get(socket.id).onclose(reason)
-                this.allClients.delete(socket.id)
+        this.websocketServer.on(ServerEvent.disconnect, (transport: Transport, reason) => {
+            if (this.allClients.has(transport.id)) {
+                this.allClients.get(transport.id).onclose(reason)
+                this.allClients.delete(transport.id)
             } else {
-                console.error(`unknow engine socket ${socket?.id} disconnect cause ${reason}`)
+                console.error(`unknow transport ${transport?.id} disconnect cause ${reason}`)
             }
         })
-        this.websocketServer.on(ServerEvent.error, (socket: SocketIO.EngineSocket, cause) => {
-            if (this.allClients.has(socket?.id)) {
-                if (socket.listeners(ServerEvent.error).length) {
-                    socket.emit(ServerEvent.error, cause)
+        this.websocketServer.on(ServerEvent.error, (transport: Transport, cause) => {
+            if (this.allClients.has(transport?.id)) {
+                let client = this.allClients.get(transport?.id)
+                if (client.listeners(ServerEvent.error).length) {
+                    client.emit(ServerEvent.error, cause)
                 } else {
-                    console.error(`engine socket ${socket.id} cause error: ${cause}`)
+                    console.error(`client ${client.id} cause error: ${cause}`)
                     console.ex(cause)
                 }
             } else {
-                console.error(`unknow engine socket ${socket?.id} cause error: ${cause}`)
+                console.error(`unknow transport ${transport?.id} cause error: ${cause}`)
                 console.ex(cause)
             }
         })
     }
-
-    private processPacket(packet: Packet, client: Client) {
-        switch (packet.type) {
-            case PacketTypes.PING:
-                client.packet({
-                    type: PacketTypes.PONG,
-                    data: packet.data
-                })
-                break
-            case PacketTypes.UPGRADE:
-                break
-            case PacketTypes.MESSAGE:
-                this.processSubPacket(packet, client)
-                break
-            case PacketTypes.CLOSE:
-                client.onclose()
-                break
-        }
-    }
-
-    private processSubPacket(packet: Packet, client: Client) {
-        let namespace = this.nsps[packet.nsp]
-        if (!namespace) {
-            client.packet({
-                type: PacketTypes.MESSAGE,
-                sub_type: SubPacketTypes.ERROR,
-                data: 'not support dynamic namespace: ' + packet.nsp
-            })
-            client.disconnect()
-            return
-        }
-        namespace.process(packet, client)
-    }
 }
+
+/**
+ * Expose main namespace (/).
+ */
+
+const emitterMethods = Object.keys(EventEmitter.prototype).filter(function (
+    key
+) {
+    return typeof EventEmitter.prototype[key] === "function"
+})
+
+emitterMethods.forEach(function (fn) {
+    Server.prototype[fn] = function () {
+        return this.sockets[fn].apply(this.sockets, arguments)
+    }
+})
+
 export {
     Server,
     Socket,

packages/websocket/src/socket-io/interfaces.ts

@@ -1,844 +0,0 @@
-export declare namespace SocketIO {
-    interface Server {
-        engine: { ws: any };
-
-		/**
-		 * A dictionary of all the namespaces currently on this Server
-		 */
-        nsps: { [namespace: string]: Namespace };
-
-		/**
-		 * The default '/' Namespace
-		 */
-        sockets: Namespace;
-
-		/**
-		 * Sets the 'json' flag when emitting an event
-		 */
-        json: Server;
-
-		/**
-		 * Sets a modifier for a subsequent event emission that the event data may be lost if the clients are not ready to receive messages
-		 */
-        volatile: Server;
-
-		/**
-		 * Sets a modifier for a subsequent event emission that the event data will only be broadcast to the current node
-		 */
-        local: Server;
-
-		/**
-		 * Server request verification function, that checks for allowed origins
-		 * @param req The http.IncomingMessage request
-		 * @param fn The callback to be called. It should take one parameter, err,
-		 * which will be null if there was no problem, and one parameter, success,
-		 * of type boolean
-		 */
-        checkRequest(req: any, fn: (err: any, success: boolean) => void): void;
-
-		/**
-		 * Gets whether we're serving the client.js file or not
-		 * @default true
-		 */
-        serveClient(): boolean;
-
-		/**
-		 * Sets whether we're serving the client.js file or not
-		 * @param v True if we want to serve the file, false otherwise
-		 * @default true
-		 * @return This Server
-		 */
-        serveClient(v: boolean): Server;
-
-		/**
-		 * Gets the client serving path
-		 * @default '/socket.io'
-		 */
-        path(): string;
-
-		/**
-		 * Sets the client serving path
-		 * @param v The path to serve the client file on
-		 * @default '/socket.io'
-		 * @return This Server
-		 */
-        path(v: string): Server;
-
-		/**
-		 * Gets the adapter that we're going to use for handling rooms
-		 * @default typeof Adapter
-		 */
-        adapter(): any;
-
-		/**
-		 * Sets the adapter (class) that we're going to use for handling rooms
-		 * @param v The class for the adapter to create
-		 * @default typeof Adapter
-		 * @return This Server
-		 */
-        adapter(v: any): Server;
-
-		/**
-		 * Gets the allowed origins for requests
-		 * @default "*:*"
-		 */
-        origins(): string | string[];
-
-		/**
-		 * Sets the allowed origins for requests
-		 * @param v The allowed origins, in host:port form
-		 * @default "*:*"
-		 * return This Server
-		 */
-        origins(v: string | string[]): Server;
-
-		/**
-		 * Provides a function taking two arguments origin:String
-		 * and callback(error, success), where success is a boolean
-		 * value indicating whether origin is allowed or not. If
-		 * success is set to false, error must be provided as a string
-		 * value that will be appended to the server response, e.g. “Origin not allowed”.
-		 * @param fn The function that will be called to check the origin
-		 * return This Server
-		 */
-        origins(fn: (origin: string, callback: (error: string | null, success: boolean) => void) => void): Server;
-
-		/**
-		 * Attaches socket.io to a server
-		 * @param srv The http.Server that we want to attach to
-		 * @param opts An optional parameters object
-		 * @return This Server
-		 */
-        attach(srv: any, opts?: ServerOptions): Server;
-
-		/**
-		 * Attaches socket.io to a port
-		 * @param port The port that we want to attach to
-		 * @param opts An optional parameters object
-		 * @return This Server
-		 */
-        attach(port: number, opts?: ServerOptions): Server;
-
-		/**
-		 * @see attach( srv, opts )
-		 */
-        listen(srv: any, opts?: ServerOptions): Server;
-
-		/**
-		 * @see attach( port, opts )
-		 */
-        listen(port: number, opts?: ServerOptions): Server;
-
-		/**
-		 * Binds socket.io to an engine.io instance
-		 * @param src The Engine.io (or compatible) server to bind to
-		 * @return This Server
-		 */
-        bind(srv: any): Server;
-
-		/**
-		 * Called with each incoming connection
-		 * @param socket The Engine.io Socket
-		 * @return This Server
-		 */
-        onconnection(socket: any): Server;
-
-		/**
-		 * Looks up/creates a Namespace
-		 * @param nsp The name of the NameSpace to look up/create. Should start
-		 * with a '/'
-		 * @return The Namespace
-		 */
-        of(nsp: string | RegExp | Function): Namespace;
-
-		/**
-		 * Closes the server connection
-		 */
-        close(fn?: () => void): void;
-
-		/**
-		 * The event fired when we get a new connection
-		 * @param event The event being fired: 'connection'
-		 * @param listener A listener that should take one parameter of type Socket
-		 * @return The default '/' Namespace
-		 */
-        on(event: 'connection', listener: (socket: Socket) => void): Namespace;
-
-		/**
-		 * @see on( 'connection', listener )
-		 */
-        on(event: 'connect', listener: (socket: Socket) => void): Namespace;
-
-		/**
-		 * Base 'on' method to add a listener for an event
-		 * @param event The event that we want to add a listener for
-		 * @param listener The callback to call when we get the event. The parameters
-		 * for the callback depend on the event
-		 * @return The default '/' Namespace
-		 */
-        on(event: string, listener: Function): Namespace;
-
-		/**
-		 * Targets a room when emitting to the default '/' Namespace
-		 * @param room The name of the room that we're targeting
-		 * @return The default '/' Namespace
-		 */
-        to(room: string): Namespace;
-
-		/**
-		 * @see to( room )
-		 */
-        in(room: string): Namespace;
-
-		/**
-		 * Registers a middleware function, which is a function that gets executed
-		 * for every incoming Socket, on the default '/' Namespace
-		 * @param fn The function to call when we get a new incoming socket. It should
-		 * take one parameter of type Socket, and one callback function to call to
-		 * execute the next middleware function. The callback can take one optional
-		 * parameter, err, if there was an error. Errors passed to middleware callbacks
-		 * are sent as special 'error' packets to clients
-		 * @return The default '/' Namespace
-		 */
-        use(fn: (socket: Socket, fn: (err?: any) => void) => void): Namespace;
-
-		/**
-		 * Emits an event to the default Namespace
-		 * @param event The event that we want to emit
-		 * @param args Any number of optional arguments to pass with the event. If the
-		 * last argument is a function, it will be called as an ack. The ack should
-		 * take whatever data was sent with the packet
-		 * @return The default '/' Namespace
-		 */
-        emit(event: string, ...args: any[]): Namespace;
-
-		/**
-		 * Sends a 'message' event
-		 * @see emit( event, ...args )
-		 * @return The default '/' Namespace
-		 */
-        send(...args: any[]): Namespace;
-
-		/**
-		 * @see send( ...args )
-		 */
-        write(...args: any[]): Namespace;
-
-		/**
-		 * Gets a list of clients
-		 * @return The default '/' Namespace
-		 */
-        clients(...args: any[]): Namespace;
-
-		/**
-		 * Sets the compress flag
-		 * @return The default '/' Namespace
-		 */
-        compress(...args: any[]): Namespace;
-    }
-
-	/**
-	 * Options to pass to our server when creating it
-	 */
-    interface ServerOptions {
-
-		/**
-		 * The path to server the client file to
-		 * @default '/socket.io'
-		 */
-        path?: string;
-
-		/**
-		 * Should we serve the client file?
-		 * @default true
-		 */
-        serveClient?: boolean;
-
-		/**
-		 * The adapter to use for handling rooms. NOTE: this should be a class,
-		 * not an object
-		 * @default typeof Adapter
-		 */
-        adapter?: Adapter;
-
-		/**
-		 * Accepted origins
-		 * @default '*:*'
-		 */
-        origins?: string | string[];
-
-		/**
-		 * How many milliseconds without a pong packed to consider the connection closed (engine.io)
-		 * @default 60000
-		 */
-        pingTimeout?: number;
-
-		/**
-		 * How many milliseconds before sending a new ping packet (keep-alive) (engine.io)
-		 * @default 25000
-		 */
-        pingInterval?: number;
-
-		/**
-		 * How many bytes or characters a message can be when polling, before closing the session
-		 * (to avoid Dos) (engine.io)
-		 * @default 10E7
-		 */
-        maxHttpBufferSize?: number;
-
-		/**
-		 * A function that receives a given handshake or upgrade request as its first parameter,
-		 * and can decide whether to continue or not. The second argument is a function that needs
-		 * to be called with the decided information: fn( err, success ), where success is a boolean
-		 * value where false means that the request is rejected, and err is an error code (engine.io)
-		 * @default null
-		 */
-        allowRequest?: (request: any, callback: (err: number, success: boolean) => void) => void;
-
-		/**
-		 * Transports to allow connections to (engine.io)
-		 * @default ['polling','websocket']
-		 */
-        transports?: string[];
-
-		/**
-		 * Whether to allow transport upgrades (engine.io)
-		 * @default true
-		 */
-        allowUpgrades?: boolean;
-
-		/**
-		 * parameters of the WebSocket permessage-deflate extension (see ws module).
-		 * Set to false to disable (engine.io)
-		 * @default true
-		 */
-        perMessageDeflate?: Object | boolean;
-
-		/**
-		 * Parameters of the http compression for the polling transports (see zlib).
-		 * Set to false to disable, or set an object with parameter "threshold:number"
-		 * to only compress data if the byte size is above this value (1024) (engine.io)
-		 * @default true|1024
-		 */
-        httpCompression?: Object | boolean;
-
-		/**
-		 * Name of the HTTP cookie that contains the client sid to send as part of
-		 * handshake response headers. Set to false to not send one (engine.io)
-		 * @default "io"
-		 */
-        cookie?: string | boolean;
-
-        /**
-         * Whether to let engine.io handle the OPTIONS requests.
-         * You can also pass a custom function to handle the requests
-         * @default true
-         */
-        handlePreflightRequest?: ((req: any, res: any) => void) | boolean;
-    }
-
-	/**
-	 * The Namespace, sandboxed environments for sockets, each connection
-	 * to a Namespace requires a new Socket
-	 */
-    interface Namespace extends NodeJS.EventEmitter {
-
-		/**
-		 * The name of the NameSpace
-		 */
-        name: string;
-
-		/**
-		 * The controller Server for this Namespace
-		 */
-        server: Server;
-
-		/**
-		 * A dictionary of all the Sockets connected to this Namespace, where
-		 * the Socket ID is the key
-		 */
-        sockets: { [id: string]: Socket };
-
-		/**
-		 * A dictionary of all the Sockets connected to this Namespace, where
-		 * the Socket ID is the key
-		 */
-        connected: { [id: string]: Socket };
-
-		/**
-		 * The Adapter that we're using to handle dealing with rooms etc
-		 */
-        adapter: Adapter;
-
-		/**
-		 * Sets the 'json' flag when emitting an event
-		 */
-        json: Namespace;
-
-		/**
-		 * Registers a middleware function, which is a function that gets executed
-		 * for every incoming Socket
-		 * @param fn The function to call when we get a new incoming socket. It should
-		 * take one parameter of type Socket, and one callback function to call to
-		 * execute the next middleware function. The callback can take one optional
-		 * parameter, err, if there was an error. Errors passed to middleware callbacks
-		 * are sent as special 'error' packets to clients
-		 * @return This Namespace
-		 */
-        use(fn: (socket: Socket, fn: (err?: any) => void) => void): Namespace;
-
-		/**
-		 * Targets a room when emitting
-		 * @param room The name of the room that we're targeting
-		 * @return This Namespace
-		 */
-        to(room: string): Namespace;
-
-		/**
-		 * @see to( room )
-		 */
-        in(room: string): Namespace;
-
-		/**
-		 * Sends a 'message' event
-		 * @see emit( event, ...args )
-		 * @return This Namespace
-		 */
-        send(...args: any[]): Namespace;
-
-		/**
-		 * @see send( ...args )
-		 */
-        write(...args: any[]): Namespace;
-
-		/**
-		 * The event fired when we get a new connection
-		 * @param event The event being fired: 'connection'
-		 * @param listener A listener that should take one parameter of type Socket
-		 * @return This Namespace
-		 */
-        on(event: 'connection', listener: (socket: Socket) => void): this;
-
-		/**
-		 * @see on( 'connection', listener )
-		 */
-        on(event: 'connect', listener: (socket: Socket) => void): this;
-
-		/**
-		 * Base 'on' method to add a listener for an event
-		 * @param event The event that we want to add a listener for
-		 * @param listener The callback to call when we get the event. The parameters
-		 * for the callback depend on the event
-		 * @ This Namespace
-		 */
-        on(event: string, listener: Function): this;
-
-		/**
-		 * Gets a list of clients.
-		 * @return This Namespace
-		 */
-        clients(fn: Function): Namespace;
-
-		/**
-		 * Sets the compress flag.
-		 * @param compress If `true`, compresses the sending data
-		 * @return This Namespace
-		 */
-        compress(compress: boolean): Namespace;
-    }
-
-    interface Packet extends Array<any> {
-		/**
-		 * Event name
-		 */
-        [0]: string;
-		/**
-		 * Packet data
-		 */
-        [1]: any;
-		/**
-		 * Ack function
-		 */
-        [2]: (...args: any[]) => void;
-    }
-
-	/**
-	 * The socket, which handles our connection for a namespace. NOTE: while
-	 * we technically extend NodeJS.EventEmitter, we're not putting it here
-	 * as we have a problem with the emit() event (as it's overridden with a
-	 * different return)
-	 */
-    interface Socket extends NodeJS.EventEmitter {
-
-		/**
-		 * The namespace that this socket is for
-		 */
-        nsp: Namespace;
-
-		/**
-		 * The Server that our namespace is in
-		 */
-        server: Server;
-
-		/**
-		 * The Adapter that we use to handle our rooms
-		 */
-        adapter: Adapter;
-
-		/**
-		 * The unique ID for this Socket. Regenerated at every connection. This is
-		 * also the name of the room that the Socket automatically joins on connection
-		 */
-        id: string;
-
-		/**
-		 * The http.IncomingMessage request sent with the connection. Useful
-		 * for recovering headers etc
-		 */
-        request: any;
-
-		/**
-		 * The Client associated with this Socket
-		 */
-        client: Client;
-
-		/**
-		 * The underlying Engine.io Socket instance
-		 */
-        conn: EngineSocket;
-
-		/**
-		 * The list of rooms that this Socket is currently in, where
-		 * the ID the the room ID
-		 */
-        rooms: { [id: string]: string };
-
-		/**
-		 * Is the Socket currently connected?
-		 */
-        connected: boolean;
-
-		/**
-		 * Is the Socket currently disconnected?
-		 */
-        disconnected: boolean;
-
-		/**
-		 * The object used when negociating the handshake
-		 */
-        handshake: Handshake;
-		/**
-		 * Sets the 'json' flag when emitting an event
-		 */
-        json: Socket;
-
-		/**
-		 * Sets the 'volatile' flag when emitting an event. Volatile messages are
-		 * messages that can be dropped because of network issues and the like. Use
-		 * for high-volume/real-time messages where you don't need to receive *all*
-		 * of them
-		 */
-        volatile: Socket;
-
-		/**
-		 * Sets the 'broadcast' flag when emitting an event. Broadcasting an event
-		 * will send it to all the other sockets in the namespace except for yourself
-		 */
-        broadcast: Socket;
-
-		/**
-		 * Targets a room when broadcasting
-		 * @param room The name of the room that we're targeting
-		 * @return This Socket
-		 */
-        to(room: string): Socket;
-
-		/**
-		 * @see to( room )
-		 */
-        in(room: string): Socket;
-
-		/**
-		 * Registers a middleware, which is a function that gets executed for every incoming Packet and receives as parameter the packet and a function to optionally defer execution to the next registered middleware.
-		 *
-		 * Errors passed to middleware callbacks are sent as special error packets to clients.
-		 */
-        use(fn: (packet: Packet, next: (err?: any) => void) => void): Socket;
-
-		/**
-		 * Sends a 'message' event
-		 * @see emit( event, ...args )
-		 */
-        send(...args: any[]): Socket;
-
-		/**
-		 * @see send( ...args )
-		 */
-        write(...args: any[]): Socket;
-
-		/**
-		 * Joins a room. You can join multiple rooms, and by default, on connection,
-		 * you join a room with the same name as your ID
-		 * @param name The name of the room that we want to join
-		 * @param fn An optional callback to call when we've joined the room. It should
-		 * take an optional parameter, err, of a possible error
-		 * @return This Socket
-		 */
-        join(name: string | string[], fn?: (err?: any) => void): Socket;
-
-		/**
-		 * Leaves a room
-		 * @param name The name of the room to leave
-		 * @param fn An optional callback to call when we've left the room. It should
-		 * take on optional parameter, err, of a possible error
-		 */
-        leave(name: string, fn?: Function): Socket;
-
-		/**
-		 * Leaves all the rooms that we've joined
-		 */
-        leaveAll(): void;
-
-		/**
-		 * Disconnects this Socket
-		 * @param close If true, also closes the underlying connection
-		 * @return This Socket
-		 */
-        disconnect(close?: boolean): Socket;
-
-		/**
-		 * Returns all the callbacks for a particular event
-		 * @param event The event that we're looking for the callbacks of
-		 * @return An array of callback Functions, or an empty array if we don't have any
-		 */
-        listeners(event: string): Function[];
-
-		/**
-		 * Sets the compress flag
-		 * @param compress If `true`, compresses the sending data
-		 * @return This Socket
-		 */
-        compress(compress: boolean): Socket;
-
-        /**
-         * Emits the error
-         * @param err Error message=
-         */
-        error(err: any): void;
-    }
-
-    interface Handshake {
-		/**
-		 * The headers passed along with the request. e.g. 'host',
-		 * 'connection', 'accept', 'referer', 'cookie'
-		 */
-        headers: any;
-
-		/**
-		 * The current time, as a string
-		 */
-        time: string;
-
-		/**
-		 * The remote address of the connection request
-		 */
-        address: string;
-
-		/**
-		 * Is this a cross-domain request?
-		 */
-        xdomain: boolean;
-
-		/**
-		 * Is this a secure request?
-		 */
-        secure: boolean;
-
-		/**
-		 * The timestamp for when this was issued
-		 */
-        issued: number;
-
-		/**
-		 * The request url
-		 */
-        url: string;
-
-		/**
-		 * Any query string parameters in the request url
-		 */
-        query: any;
-    }
-
-	/**
-	 * The interface describing a room
-	 */
-    interface Room {
-        sockets: { [id: string]: boolean };
-        length: number;
-    }
-
-	/**
-	 * The interface describing a dictionary of rooms
-	 * Where room is the name of the room
-	 */
-
-    interface Rooms {
-        [room: string]: Room;
-    }
-
-	/**
-	 * The interface used when dealing with rooms etc
-	 */
-    interface Adapter extends NodeJS.EventEmitter {
-
-		/**
-		 * The namespace that this adapter is for
-		 */
-        nsp: Namespace;
-
-		/**
-		 * A dictionary of all the rooms that we have in this namespace
-		 */
-        rooms: Rooms;
-
-		/**
-		 * A dictionary of all the socket ids that we're dealing with, and all
-		 * the rooms that the socket is currently in
-		 */
-        sids: { [id: string]: { [room: string]: boolean } };
-
-		/**
-		 * Adds a socket to a room. If the room doesn't exist, it's created
-		 * @param id The ID of the socket to add
-		 * @param room The name of the room to add the socket to
-		 * @param callback An optional callback to call when the socket has been
-		 * added. It should take an optional parameter, error, if there was a problem
-		 */
-        add(id: string, room: string, callback?: (err?: any) => void): void;
-
-		/**
-		 * Removes a socket from a room. If there are no more sockets in the room,
-		 * the room is deleted
-		 * @param id The ID of the socket that we're removing
-		 * @param room The name of the room to remove the socket from
-		 * @param callback An optional callback to call when the socket has been
-		 * removed. It should take on optional parameter, error, if there was a problem
-		 */
-        del(id: string, room: string, callback?: (err?: any) => void): void;
-
-        /**
-         * Adds a socket to a list of room.
-         *
-         * @param {String} socket id
-         * @param {String} rooms
-         * @param {Function} callback
-         * @api public
-         */
-        addAll(id: string, rooms: string | any[], fn: { (err?: any): void; bind?: any; });
-
-		/**
-		 * Removes a socket from all the rooms that it's joined
-		 * @param id The ID of the socket that we're removing
-		 */
-        delAll(id: string): void;
-
-		/**
-		 * Broadcasts a packet
-		 * @param packet The packet to broadcast
-		 * @param opts Any options to send along:
-		 * 	- rooms: An optional list of rooms to broadcast to. If empty, the packet is broadcast to all sockets
-		 * 	- except: A list of Socket IDs to exclude
-		 * 	- flags: Any flags that we want to send along ('json', 'volatile', 'broadcast')
-		 */
-        broadcast(packet: any, opts: { rooms?: string[]; except?: string[]; flags?: { [flag: string]: boolean } }): void;
-    }
-
-	/**
-	 * The client behind each socket (can have multiple sockets)
-	 */
-    interface Client {
-		/**
-		 * The Server that this client belongs to
-		 */
-        server: Server;
-
-		/**
-		 * The underlying Engine.io Socket instance
-		 */
-        conn: EngineSocket;
-
-		/**
-		 * The ID for this client. Regenerated at every connection
-		 */
-        id: string;
-
-		/**
-		 * The http.IncomingMessage request sent with the connection. Useful
-		 * for recovering headers etc
-		 */
-        request: any;
-
-		/**
-		 * The dictionary of sockets currently connect via this client (i.e. to different
-		 * namespaces) where the Socket ID is the key
-		 */
-        sockets: { [id: string]: Socket };
-
-		/**
-		 * A dictionary of all the namespaces for this client, with the Socket that
-		 * deals with that namespace
-		 */
-        nsps: { [nsp: string]: Socket };
-    }
-
-	/**
-	 * A reference to the underlying engine.io Socket connection.
-	 */
-    interface EngineSocket extends NodeJS.EventEmitter {
-		/**
-		 * The ID for this socket - matches Client.id
-		 */
-        id: string;
-
-		/**
-		 * The Engine.io Server for this socket
-		 */
-        server: any;
-
-		/**
-		 * The ready state for the client. Either 'opening', 'open', 'closing', or 'closed'
-		 */
-        readyState: string;
-
-		/**
-		 * The remote IP for this connection
-		 */
-        remoteAddress: string;
-
-		/**
-		 * whether the transport has been upgraded
-		 */
-        upgraded: boolean;
-
-		/**
-		 * (http.IncomingMessage): request that originated the Socket
-		 */
-        request: any;
-
-		/**
-		 * (Transport): transport reference
-		 */
-        transport: any;
-
-        /**
-         * send
-         */
-        send(text: string);
-
-        /**
-         * close
-         */
-        close();
-    }
-}

packages/websocket/src/socket-io/namespace.ts

@@ -1,85 +1,153 @@
 import { EventEmitter } from 'events'
 
 import { Client } from './client'
-import { SocketIO } from './interfaces'
 import { ServerEvent } from './constants'
-import { Socket } from './socket'
-import { Adapter } from './adapter'
+import { RESERVED_EVENTS, Socket } from './socket'
+import { Adapter, Room, SocketId } from './adapter'
 import { Server } from './index'
 import { Packet } from './packet'
 import { PacketTypes, SubPacketTypes } from './types'
 
-export class Namespace extends EventEmitter implements SocketIO.Namespace {
-    name: string
-    server: Server
-    sockets: { [id: string]: Socket }
-    connected: { [id: string]: Socket }
-    adapter: SocketIO.Adapter
-    json: SocketIO.Namespace
+export interface ExtendedError extends Error {
+    data?: any
+}
 
-    fns: any[]
-    ids: number
-    rooms: string[]
-    flags: { [key: string]: boolean }
+export class Namespace extends EventEmitter {
+    public readonly name: string
+    public readonly sockets: Map<SocketId, Socket>
 
-    private events = ['connect', 'connection', 'newListener']
+    public adapter: Adapter
 
-    constructor(name: string, server: Server) {
+    /** @private */
+    readonly server: Server
+    json: Namespace
+
+    /** @private */
+    _fns: Array<
+        (socket: Socket, next: (err: ExtendedError) => void) => void
+    > = [];
+
+    /** @private */
+    _rooms: Set<Room>
+
+    /** @private */
+    _flags: any = {}
+
+    /** @private */
+    _ids: number = 0
+
+    constructor(server: Server, name: string) {
         super()
-        this.name = name
         this.server = server
-        this.sockets = {}
-        this.connected = {}
-        this.fns = []
-        this.ids = 0
-        this.rooms = []
-        this.flags = {}
-        this.adapter = new Adapter(this)
+        this.name = name + ''
+        this._initAdapter()
+        // =======================
+        this.sockets = new Map()
+        this._rooms = new Set()
     }
-    initAdapter() {
+    _initAdapter() {
         // @ts-ignore
-        this.adapter = new (this.server.adapter())()
+        this.adapter = new (this.server.adapter())(this)
     }
-    add(client: Client, query?: any, callback?: () => void) {
-        // client.conn.request.url();
-        let socket = new Socket(this, client, {})
-        this.sockets[client.id] = socket
-        client.nsps[this.name] = socket
-        this.onconnection(socket)
+    /**
+     * Sets up namespace middleware.
+     *
+     * @return {Namespace} self
+     * @public
+     */
+    public use(
+        fn: (socket: Socket, next: (err?: ExtendedError) => void) => void
+    ): Namespace {
+        this._fns.push(fn)
+        return this
+    }
+    /**
+     * Executes the middleware for an incoming client.
+     *
+     * @param {Socket} socket - the socket that will get added
+     * @param {Function} fn - last fn call in the middleware
+     * @private
+     */
+    private run(socket: Socket, fn: (err: ExtendedError) => void) {
+        const fns = this._fns.slice(0)
+        if (!fns.length) return fn(null)
+
+        function run(i) {
+            fns[i](socket, function (err) {
+                // upon error, short-circuit
+                if (err) return fn(err)
+
+                // if no middleware left, summon callback
+                if (!fns[i + 1]) return fn(null)
+
+                // go on to next
+                run(i + 1)
+            })
+        }
+
+        run(0)
+    }
+    to(name: string): Namespace {
+        this._rooms.add(name)
+        return this
+    }
+    in(name: string): Namespace {
+        return this.to(name)
+    }
+    _add(client: Client, query?: any, fn?: (socket: Socket) => void) {
+        const socket = new Socket(this, client, query || {})
+        console.debug(`client ${client.id} adding socket ${socket.id} to nsp ${this.name}`)
+        this.run(socket, err => {
+            process.nextTick(() => {
+                if ("open" == client.conn.readyState) {
+                    if (err)
+                        return socket._error({
+                            message: err.message,
+                            data: err.data
+                        })
+
+                    // track socket
+                    this.sockets.set(socket.id, socket)
+
+                    // it's paramount that the internal `onconnect` logic
+                    // fires before user-set events to prevent state order
+                    // violations (such as a disconnection before the connection
+                    // logic is complete)
+                    socket._onconnect()
+                    // !!! at java multi thread need direct callback socket
+                    if (fn) fn(socket)
+
+                    // fire user-set events
+                    super.emit(ServerEvent.connect, socket)
+                    super.emit(ServerEvent.connection, socket)
+                } else {
+                    console.debug(`next called after client ${client.id} was closed - ignoring socket`)
+                }
+            })
+        })
         return socket
     }
-    del(client: Client) {
-        let socket = this.sockets[client.id]
-        socket.disconnect()
-        delete this.sockets[client.id]
-    }
-    use(fn: (socket: SocketIO.Socket, fn: (err?: any) => void) => void): SocketIO.Namespace {
-        throw new Error("Method not implemented.")
-    }
-    to(room: string): SocketIO.Namespace {
-        if (!~this.rooms.indexOf(room)) this.rooms.push(room)
-        return this
-    }
-    in(room: string): SocketIO.Namespace {
-        return this.to(room)
-    }
-    send(...args: any[]): SocketIO.Namespace {
-        super.emit('message', ...args)
-        return this
-    }
-    write(...args: any[]): SocketIO.Namespace {
-        return this.send(...args)
+    /**
+     * Removes a client. Called by each `Socket`.
+     *
+     * @private
+     */
+    _remove(socket: Socket): void {
+        if (this.sockets.has(socket.id)) {
+            console.debug(`namespace ${this.name} remove socket ${socket.id}`)
+            this.sockets.delete(socket.id)
+        } else {
+            console.debug(`namespace ${this.name} ignoring remove for ${socket.id}`)
+        }
     }
     emit(event: string, ...args: any[]): boolean {
-        if (~this.events.indexOf(event)) {
-            super.emit(event, ...args)
-            // @ts-ignore
-            return this
+        if (RESERVED_EVENTS.has(event)) {
+            throw new Error(`"${event}" is a reserved event name`)
         }
         // set up packet object
         var packet = {
             type: PacketTypes.MESSAGE,
-            sub_type: (this.flags.binary !== undefined ? this.flags.binary : this.hasBin(args)) ? SubPacketTypes.BINARY_EVENT : SubPacketTypes.EVENT,
+            sub_type: (this._flags.binary !== undefined ? this._flags.binary : this.hasBin(args)) ? SubPacketTypes.BINARY_EVENT : SubPacketTypes.EVENT,
             name: event,
             data: args
         }
@@ -88,55 +156,87 @@ export class Namespace extends EventEmitter implements SocketIO.Namespace {
             throw new Error('Callbacks are not supported when broadcasting')
         }
 
-        var rooms = this.rooms.slice(0)
-        var flags = Object.assign({}, this.flags)
+        var rooms = new Set(this._rooms)
+        var flags = Object.assign({}, this._flags)
 
         // reset flags
-        this.rooms = []
-        this.flags = {}
+        this._rooms.clear()
+        this._flags = {}
 
         this.adapter.broadcast(packet, {
-            rooms: rooms,
+            rooms: new Set(rooms),
             flags: flags
         })
         // @ts-ignore
         return this
     }
+    send(...args: any[]): Namespace {
+        this.emit('message', ...args)
+        return this
+    }
+    write(...args: any[]): Namespace {
+        return this.send(...args)
+    }
+    /**
+     * Gets a list of clients.
+     *
+     * @return {Namespace} self
+     * @public
+     */
+    public allSockets(): Promise<Set<SocketId>> {
+        if (!this.adapter) {
+            throw new Error("No adapter for this namespace, are you trying to get the list of clients of a dynamic namespace?")
+        }
+        const rooms = new Set(this._rooms)
+        this._rooms.clear()
+        return this.adapter.sockets(rooms)
+    }
+
+    /**
+     * Sets the compress flag.
+     *
+     * @param {Boolean} compress - if `true`, compresses the sending data
+     * @return {Namespace} self
+     * @public
+     */
+    public compress(compress: boolean): Namespace {
+        this._flags.compress = compress
+        return this
+    }
+
+    /**
+     * Sets a modifier for a subsequent event emission that the event data may be lost if the client is not ready to
+     * receive messages (because of network slowness or other issues, or because they’re connected through long polling
+     * and is in the middle of a request-response cycle).
+     *
+     * @return {Namespace} self
+     * @public
+     */
+    public get volatile(): Namespace {
+        this._flags.volatile = true
+        return this
+    }
+
+    /**
+     * Sets a modifier for a subsequent event emission that the event data will only be broadcast to the current node.
+     *
+     * @return {Namespace} self
+     * @public
+     */
+    public get local(): Namespace {
+        this._flags.local = true
+        return this
+    }
+
     hasBin(args: any[]) {
         return false
     }
-    clients(fn: (sockets: Socket[]) => SocketIO.Namespace): SocketIO.Namespace {
+    clients(fn: (sockets: Socket[]) => Namespace): Namespace {
         return fn(Object.values(this.sockets))
     }
-    compress(compress: boolean): SocketIO.Namespace {
-        throw new Error("Method not implemented.")
-    }
-    process(packet: Packet, client: Client) {
-        switch (packet.sub_type) {
-            case SubPacketTypes.CONNECT:
-                this.add(client)
-                break
-            default:
-                this.sockets[client.id].onpacket(packet)
-                break
-        }
-    }
-    remove(socket: Socket) {
-        if (this.sockets.hasOwnProperty(socket.id)) {
-            delete this.sockets[socket.id]
-        } else {
-            // debug('ignoring remove for %s', socket.id);
-        }
-    }
     close() {
-        this.removeAllListeners('connect')
+        this.removeAllListeners(ServerEvent.connect)
+        this.removeAllListeners(ServerEvent.connection)
         Object.values(this.sockets).forEach(socket => socket.disconnect(false))
     }
-    private onconnection(socket: any) {
-        let client = socket as Socket
-        this.sockets[client.id] = client
-        this.emit(ServerEvent.connect, socket)
-        client.onconnect()
-        this.emit(ServerEvent.connection, socket)
-    }
 }

packages/websocket/src/socket-io/parent-namespace.ts

@@ -0,0 +1,40 @@
+import { Namespace } from "./namespace"
+
+export class ParentNamespace extends Namespace {
+    private static count: number = 0;
+    private children: Set<Namespace> = new Set();
+
+    constructor(server) {
+        super(server, "/_" + ParentNamespace.count++)
+    }
+
+    _initAdapter() { }
+
+    public emit(...args: any[]): boolean {
+        this.children.forEach(nsp => {
+            nsp._rooms = this._rooms
+            nsp._flags = this._flags
+            nsp.emit.apply(nsp, args as any)
+        })
+        this._rooms.clear()
+        this._flags = {}
+
+        return true
+    }
+
+    createChild(name) {
+        const namespace = new Namespace(this.server, name)
+        namespace._fns = this._fns.slice(0)
+        this.listeners("connect").forEach(listener =>
+            // @ts-ignore
+            namespace.on("connect", listener)
+        )
+        this.listeners("connection").forEach(listener =>
+            // @ts-ignore
+            namespace.on("connection", listener)
+        )
+        this.children.add(namespace)
+        this.server._nsps.set(name, namespace)
+        return namespace
+    }
+}

packages/websocket/src/socket-io/parser.ts

@@ -1,30 +1,31 @@
-import { Packet } from "./packet";
-import { PacketTypes, SubPacketTypes } from "./types";
+import { EventEmitter } from 'events'
+import { Packet } from "./packet"
+import { PacketTypes, SubPacketTypes } from "./types"
 
-export class Parser {
+export class Parser extends EventEmitter {
     encode(packet: Packet): string {
         let origin = JSON.stringify(packet)
         // first is type
-        let str = '' + packet.type;
+        let str = '' + packet.type
         if (packet.type == PacketTypes.PONG) {
             if (packet.data) { str += packet.data };
-            return str;
+            return str
         }
         if (packet.sub_type != undefined) {
-            str += packet.sub_type;
+            str += packet.sub_type
         }
         // attachments if we have them
         if ([SubPacketTypes.BINARY_EVENT, SubPacketTypes.BINARY_ACK].includes(packet.sub_type)) {
-            str += packet.attachments + '-';
+            str += packet.attachments + '-'
         }
         // if we have a namespace other than `/`
         // we append it followed by a comma `,`
         if (packet.nsp && '/' !== packet.nsp) {
-            str += packet.nsp + ',';
+            str += packet.nsp + ','
         }
         // immediately followed by the id
         if (null != packet.id) {
-            str += packet.id;
+            str += packet.id
         }
         if (packet.sub_type == SubPacketTypes.EVENT) {
             if (packet.name == undefined) { throw new Error(`SubPacketTypes.EVENT name can't be empty!`) }
@@ -32,25 +33,25 @@ export class Parser {
         }
         // json data
         if (null != packet.data) {
-            let payload = this.tryStringify(packet.data);
+            let payload = this.tryStringify(packet.data)
             if (payload !== false) {
-                str += payload;
+                str += payload
             } else {
                 return '4"encode error"'
             }
         }
-        console.trace(`encoded ${origin} as ${str}`);
-        return str;
+        console.trace(`encoded ${origin} as ${str}`)
+        return str
     }
     tryStringify(str: any) {
         try {
-            return JSON.stringify(str);
+            return JSON.stringify(str)
         } catch (e) {
-            return false;
+            return false
         }
     }
     decode(str: string): Packet {
-        let i = 0;
+        let i = 0
         // ignore parse binary
         // if ((frame.getByte(0) == 'b' && frame.getByte(1) == '4')
         //     || frame.getByte(0) == 4 || frame.getByte(0) == 1) {
@@ -59,69 +60,69 @@ export class Parser {
         // look up type
         let p: Packet = {
             type: Number(str.charAt(i))
-        };
+        }
         if (null == PacketTypes[p.type]) {
-            return this.error('unknown packet type ' + p.type);
+            return this.error('unknown packet type ' + p.type)
         }
         // if str empty return
         if (str.length == i + 1) {
-            return p;
+            return p
         }
         // if is ping packet read data and return
         if (PacketTypes.PING == p.type) {
-            p.data = str.substr(++i);
-            return p;
+            p.data = str.substr(++i)
+            return p
         }
         // look up sub type
-        p.sub_type = Number(str.charAt(++i));
+        p.sub_type = Number(str.charAt(++i))
         if (null == PacketTypes[p.sub_type]) {
-            return this.error('unknown sub packet type ' + p.type);
+            return this.error('unknown sub packet type ' + p.type)
         }
         // look up attachments if type binary
         if ([SubPacketTypes.BINARY_ACK, SubPacketTypes.BINARY_EVENT].includes(p.sub_type)) {
-            let buf = '';
+            let buf = ''
             while (str.charAt(++i) !== '-') {
-                buf += str.charAt(i);
-                if (i == str.length) break;
+                buf += str.charAt(i)
+                if (i == str.length) break
             }
             if (buf != `${Number(buf)}` || str.charAt(i) !== '-') {
-                return this.error('Illegal attachments');
+                return this.error('Illegal attachments')
             }
-            p.attachments = Number(buf);
+            p.attachments = Number(buf)
         }
 
         // look up namespace (if any)
         if ('/' === str.charAt(i + 1)) {
-            p.nsp = '';
+            p.nsp = ''
             while (++i) {
-                let c = str.charAt(i);
-                if (',' === c) break;
-                p.nsp += c;
-                if (i === str.length) break;
+                let c = str.charAt(i)
+                if (',' === c) break
+                p.nsp += c
+                if (i === str.length) break
             }
         } else {
-            p.nsp = '/';
+            p.nsp = '/'
         }
 
         // handle namespace query
         if (p.nsp.indexOf('?') !== -1) {
-            p.nsp = p.nsp.split('?')[0];
+            p.nsp = p.nsp.split('?')[0]
         }
 
         // look up id
-        let next = str.charAt(i + 1);
+        let next = str.charAt(i + 1)
         if ('' !== next && !isNaN(Number(next))) {
             let id = ''
             while (++i) {
-                let c = str.charAt(i);
+                let c = str.charAt(i)
                 if (null == c || isNaN(Number(c))) {
-                    --i;
-                    break;
+                    --i
+                    break
                 }
-                id += str.charAt(i);
-                if (i === str.length) break;
+                id += str.charAt(i)
+                if (i === str.length) break
             }
-            p.id = Number(id);
+            p.id = Number(id)
         }
 
         // ignore binary packet
@@ -131,25 +132,25 @@ export class Parser {
 
         // look up json data
         if (str.charAt(++i)) {
-            let payload = this.tryParse(str.substr(i));
-            let isPayloadValid = payload !== false && (p.sub_type == SubPacketTypes.ERROR || Array.isArray(payload));
+            let payload = this.tryParse(str.substr(i))
+            let isPayloadValid = payload !== false && (p.sub_type == SubPacketTypes.ERROR || Array.isArray(payload))
             if (isPayloadValid) {
-                p.name = payload[0];
-                p.data = payload.slice(1);
+                p.name = payload[0]
+                p.data = payload.slice(1)
             } else {
-                return this.error('invalid payload ' + str.substr(i));
+                return this.error('invalid payload ' + str.substr(i))
             }
         }
 
-        console.trace(`decoded ${str} as ${JSON.stringify(p)}`);
-        return p;
+        console.trace(`decoded ${str} as ${JSON.stringify(p)}`)
+        return p
     }
 
     tryParse(str: string) {
         try {
-            return JSON.parse(str);
+            return JSON.parse(str)
         } catch (e) {
-            return false;
+            return false
         }
     }
 
@@ -158,6 +159,6 @@ export class Parser {
             type: PacketTypes.MESSAGE,
             sub_type: SubPacketTypes.ERROR,
             data: 'parser error: ' + error
-        };
+        }
     }
-}
+}

packages/websocket/src/socket-io/socket.ts

@@ -1,166 +1,110 @@
 import { EventEmitter } from 'events'
 
-import { SocketIO } from "./interfaces"
 import { Packet } from './packet'
 import { PacketTypes, SubPacketTypes } from './types'
 import { Client } from './client'
 import { Namespace } from './namespace'
 import * as querystring from 'querystring'
 import { ServerEvent } from './constants'
+import { Adapter, BroadcastFlags, Room, SocketId } from './adapter'
+import { Server } from 'index'
 
-export class Socket extends EventEmitter implements SocketIO.Socket {
+export const RESERVED_EVENTS = new Set([
+    "connect",
+    "connect_error",
+    "disconnect",
+    "disconnecting",
+    // EventEmitter reserved events: https://nodejs.org/api/events.html#events_event_newlistener
+    "newListener",
+    "removeListener"
+])
+
+/**
+ * The handshake details
+ */
+export interface Handshake {
+    /**
+     * The headers sent as part of the handshake
+     */
+    headers: object
+
+    /**
+     * The date of creation (as string)
+     */
+    time: string
+
+    /**
+     * The ip of the client
+     */
+    address: string
+
+    /**
+     * Whether the connection is cross-domain
+     */
+    xdomain: boolean
+
+    /**
+     * Whether the connection is secure
+     */
+    secure: boolean
+
+    /**
+     * The date of creation (as unix timestamp)
+     */
+    issued: number
+
+    /**
+     * The request URL string
+     */
+    url: string
+
+    /**
+     * The query object
+     */
+    query: any
+
+    /**
+     * The auth object
+     */
+    auth: any
+}
+export class Socket extends EventEmitter {
     nsp: Namespace
-    server: SocketIO.Server
-    adapter: SocketIO.Adapter
-    id: string
-    request: any
+
+    public readonly id: SocketId
+    public readonly handshake: Handshake
+
+    public connected: boolean
+    public disconnected: boolean
+
+    private readonly server: Server
+    private readonly adapter: Adapter
+
     client: Client
-    conn: SocketIO.EngineSocket
-    rooms: { [id: string]: string }
-    acks: { [id: string]: Function }
-    connected: boolean
-    disconnected: boolean
-    handshake: SocketIO.Handshake
+    private acks: Map<number, () => void>
+
     fns: any[]
-    flags: { [key: string]: boolean }
-    _rooms: string[]
+    private flags: BroadcastFlags = {};
+    private _rooms: Set<Room> = new Set();
+    private _anyListeners: Array<(...args: any[]) => void>
 
-    private events = [
-        'error',
-        'connect',
-        'disconnect',
-        'disconnecting',
-        'newListener',
-        'removeListener'
-    ]
-
-    constructor(nsp: Namespace, client: Client, query = {}) {
+    constructor(nsp: Namespace, client: Client, auth = {}) {
         super()
         this.nsp = nsp
         this.server = nsp.server
         this.adapter = this.nsp.adapter
         this.id = nsp.name !== '/' ? nsp.name + '#' + client.id : client.id
         this.client = client
-        this.request = client.request
-        this.conn = client.conn
-        this.rooms = {}
-        this.acks = {}
+        this.acks = new Map()
         this.connected = true
         this.disconnected = false
-        this.handshake = this.buildHandshake(query)
+        this.handshake = this.buildHandshake(auth)
+
         this.fns = []
         this.flags = {}
-        this._rooms = []
-    }
-
-    get json() {
-        this.flags.json = true
-        return this
-    }
-
-    get volatile() {
-        this.flags.volatile = true
-        return this
-    }
-    get broadcast() {
-        this.flags.broadcast = true
-        return this
-    }
-    get local() {
-        this.flags.local = true
-        return this
-    }
-
-    to(room: string): SocketIO.Socket {
-        if (!~this._rooms.indexOf(room)) this._rooms.push(room)
-        return this
-    }
-    in(room: string): SocketIO.Socket {
-        return this.to(room)
-    }
-    use(fn: (packet: SocketIO.Packet, next: (err?: any) => void) => void): SocketIO.Socket {
-        throw new Error("Method not implemented.")
-    }
-    send(...args: any[]): SocketIO.Socket {
-        this.emit("message", ...args)
-        return this
-    }
-    write(...args: any[]): SocketIO.Socket {
-        return this.send(...args)
-    }
-    join(rooms: string | string[], fn?: (err?: any) => void): SocketIO.Socket {
-        if (!Array.isArray(rooms)) {
-            rooms = [rooms]
-        }
-        rooms = rooms.filter((room) => {
-            return !this.rooms.hasOwnProperty(room)
-        })
-        if (!rooms.length) {
-            fn && fn(null)
-            return this
-        }
-        this.adapter.addAll(this.id, rooms, (err) => {
-            if (err) return fn && fn(err);
-            // debug('joined room %s', rooms);
-            (rooms as Array<string>).forEach((room) => {
-                this.rooms[room] = room
-            })
-            fn && fn(null)
-        })
-        return this
-    }
-    leave(name: string, fn?: Function): SocketIO.Socket {
-        delete this.rooms[name]
-        fn && fn(null)
-        return this
-    }
-    leaveAll(): void {
-        this.adapter.delAll(this.id)
-        this.rooms = {}
-    }
-    disconnect(close?: boolean): SocketIO.Socket {
-        if (!this.connected) return this
-        if (close) {
-            this.client.disconnect()
-        } else {
-            this.packet({ type: PacketTypes.MESSAGE, sub_type: SubPacketTypes.DISCONNECT })
-            this.onclose('server namespace disconnect')
-        }
-        return this
-    }
-    compress(compress: boolean): SocketIO.Socket {
-        throw new Error("Method not implemented.")
-    }
-    error(err: any): void {
-        this.packet({ type: PacketTypes.MESSAGE, sub_type: SubPacketTypes.ERROR, data: err })
-    }
-
-    // ==========================================
-    buildHandshake(query): SocketIO.Handshake {
-        let requestUri = this.request.uri()
-        let headers = {}
-        let nativeHeaders = this.request.headers()
-        nativeHeaders.forEach(function (header) {
-            headers[header.getKey()] = header.getValue()
-        })
-        return {
-            headers: headers,
-            time: (new Date) + '',
-            address: this.conn.remoteAddress + '',
-            xdomain: !!headers['origin'],
-            secure: false,
-            issued: +(new Date),
-            url: requestUri,
-            query: Object.assign(query, querystring.parse(requestUri.indexOf('?') != -1 ? requestUri.split('?')[1] : ''))
-        }
+        this._rooms = new Set()
     }
     emit(event: string, ...args: any[]): boolean {
-        if (~this.events.indexOf(event)) {
-            super.emit(event, ...args)
-            // @ts-ignore
-            return this
-        }
-
         let packet: Packet = {
             type: PacketTypes.MESSAGE,
             sub_type: (this.flags.binary !== undefined ? this.flags.binary : this.hasBin(args)) ? SubPacketTypes.BINARY_EVENT : SubPacketTypes.EVENT,
@@ -169,25 +113,26 @@ export class Socket extends EventEmitter implements SocketIO.Socket {
         }
 
         // access last argument to see if it's an ACK callback
-        if (typeof args[args.length - 1] === 'function') {
-            if (this._rooms.length || this.flags.broadcast) {
-                throw new Error('Callbacks are not supported when broadcasting')
+        if (typeof args[args.length - 1] === "function") {
+            if (this._rooms.size || this.flags.broadcast) {
+                throw new Error("Callbacks are not supported when broadcasting")
             }
-            // debug('emitting packet with ack id %d', this.nsp.ids);
-            this.acks[this.nsp.ids] = args.pop()
-            packet.id = this.nsp.ids++
+
+            // console.debug("emitting packet with ack id %d", this.nsp._ids)
+            this.acks.set(this.nsp._ids, args.pop())
+            packet.id = this.nsp._ids++
         }
 
-        let rooms = this._rooms.slice(0)
-        let flags = Object.assign({}, this.flags)
+        const rooms = new Set(this._rooms)
+        const flags = Object.assign({}, this.flags)
 
         // reset flags
-        this._rooms = []
+        this._rooms.clear()
         this.flags = {}
 
-        if (rooms.length || flags.broadcast) {
+        if (rooms.size || flags.broadcast) {
             this.adapter.broadcast(packet, {
-                except: [this.id],
+                except: new Set([this.id]),
                 rooms: rooms,
                 flags: flags
             })
@@ -195,47 +140,69 @@ export class Socket extends EventEmitter implements SocketIO.Socket {
             // dispatch packet
             this.packet(packet, flags)
         }
-        // @ts-ignore
+        return true
+    }
+    to(name: Room): Socket {
+        this._rooms.add(name)
         return this
     }
-    packet(packet: Packet, opts: any = { preEncoded: false }) {
-        if (!opts.preEncoded) {
-            packet.nsp = this.nsp.name
-            opts.compress = false !== opts.compress
-        }
-        try {
-            this.client.packet(packet, opts)
-        } catch (error) {
-            this.onerror(error)
-        }
+    in(room: string): Socket {
+        return this.to(room)
     }
-    onconnect() {
-        this.nsp.connected[this.id] = this
-        this.client.sockets[this.id] = this
+    use(fn: (packet: Packet, next: (err?: any) => void) => void): Socket {
+        throw new Error("Method not implemented.")
+    }
+    send(...args: any[]): Socket {
+        this.emit("message", ...args)
+        return this
+    }
+    write(...args: any[]): Socket {
+        return this.send(...args)
+    }
+    public join(rooms: Room | Array<Room>): Promise<void> | void {
+        console.debug(`join room ${rooms}`)
+
+        return this.adapter.addAll(
+            this.id,
+            new Set(Array.isArray(rooms) ? rooms : [rooms])
+        )
+    }
+    /**
+     * Leaves a room.
+     *
+     * @param {String} room
+     * @return a Promise or nothing, depending on the adapter
+     * @public
+     */
+    public leave(room: string): Promise<void> | void {
+        console.debug(`leave room ${room}`)
+
+        return this.adapter.del(this.id, room)
+    }
+
+    /**
+     * Leave all rooms.
+     *
+     * @private
+     */
+    private leaveAll(): void {
+        this.adapter.delAll(this.id)
+    }
+
+    /**
+      * Called by `Namespace` upon successful
+      * middleware execution (ie: authorization).
+      * Socket is added to namespace array before
+      * call to join, so adapters can access it.
+      *
+      * @private
+      */
+    _onconnect(): void {
+        console.debug(`socket ${this.id} connected - writing packet`)
         this.join(this.id)
-        // let skip = this.nsp.name === '/' && this.nsp.fns.length === 0;
-        // if (skip) {
-        // debug('packet already sent in initial handshake');
-        // } else {
-        this.packet({
-            type: PacketTypes.MESSAGE,
-            sub_type: SubPacketTypes.CONNECT
-        })
-        // }
+        this.packet({ type: PacketTypes.MESSAGE, sub_type: SubPacketTypes.CONNECT, data: { sid: this.id } })
     }
-    onclose(reason?: string) {
-        if (!this.connected) return this
-        // debug('closing socket - reason %s', reason);
-        this.emit('disconnecting', reason)
-        this.leaveAll()
-        this.nsp.remove(this)
-        this.client.remove(this)
-        this.connected = false
-        this.disconnected = true
-        delete this.nsp.connected[this.id]
-        this.emit('disconnect', reason)
-    }
-    onpacket(packet: Packet) {
+    _onpacket(packet: Packet) {
         switch (packet.sub_type) {
             // 2
             case SubPacketTypes.EVENT:
@@ -259,23 +226,12 @@ export class Socket extends EventEmitter implements SocketIO.Socket {
                 break
             // 4
             case SubPacketTypes.ERROR:
-                this.onerror(new Error(packet.data))
+                this._onerror(new Error(packet.data))
         }
     }
-    onerror(err: Error) {
-        if (this.listeners('error').length) {
-            this.emit('error', err)
-        } else {
-            console.error('Missing error handler on `socket`.')
-            console.error(err.stack)
-        }
-    }
-    ondisconnect() {
-        this.onclose('client namespace disconnect')
-    }
     onevent(packet: Packet) {
         if (null != packet.id) {
-            // debug('attaching ack callback to event');
+            console.trace(`attaching ack ${packet.id} callback to client ${this.id} event`)
             this.dispatch(packet, this.ack(packet.id))
         } else {
             this.dispatch(packet)
@@ -295,17 +251,238 @@ export class Socket extends EventEmitter implements SocketIO.Socket {
         }
     }
     onack(packet: Packet) {
-        let ack = this.acks[packet.id]
+        let ack = this.acks.get(packet.id)
         if ('function' == typeof ack) {
-            // debug('calling ack %s with %j', packet.id, packet.data);
+            console.trace(`calling ack ${packet.id} on socket ${this.id} with ${packet.data}`)
             ack.apply(this, packet.data)
-            delete this.acks[packet.id]
+            this.acks.delete(packet.id)
         } else {
-            // debug('bad ack %s', packet.id);
+            console.trace(`bad ack ${packet.id} on socket ${this.id}`)
         }
     }
-    dispatch(packet: Packet, ack?: Function) {
-        if (ack) { this.acks[packet.id] = ack }
+    /**
+     * Called upon client disconnect packet.
+     *
+     * @private
+     */
+    private ondisconnect(): void {
+        console.debug(`socket ${this.id} got disconnect packet`)
+        this._onclose("client namespace disconnect")
+    }
+
+    /**
+     * Handles a client error.
+     *
+     * @private
+     */
+    _onerror(err): void {
+        if (this.listeners("error").length) {
+            super.emit("error", err)
+        } else {
+            console.error(`Missing error handler on 'socket(${this.id})'.`)
+            console.error(err.stack)
+        }
+    }
+
+    /**
+     * Called upon closing. Called by `Client`.
+     *
+     * @param {String} reason
+     * @throw {Error} optional error object
+     *
+     * @private
+     */
+    _onclose(reason: string) {
+        if (!this.connected) return this
+        console.debug(`closing socket ${this.id} - reason: ${reason} connected: ${this.connected}`)
+        super.emit(ServerEvent.disconnecting, reason)
+        this.leaveAll()
+        this.nsp._remove(this)
+        this.client._remove(this)
+        this.connected = false
+        this.disconnected = true
+        super.emit(ServerEvent.disconnect, reason)
+    }
+
+    /**
+     * Produces an `error` packet.
+     *
+     * @param {Object} err - error object
+     *
+     * @private
+     */
+    _error(err) {
+        this.packet({ type: PacketTypes.MESSAGE, sub_type: SubPacketTypes.ERROR, data: err })
+    }
+    disconnect(close?: boolean): Socket {
+        if (!this.connected) return this
+        if (close) {
+            this.client._disconnect()
+        } else {
+            this.packet({ type: PacketTypes.MESSAGE, sub_type: SubPacketTypes.DISCONNECT })
+            this._onclose('server namespace disconnect')
+        }
+        return this
+    }
+
+    compress(compress: boolean): Socket {
+        throw new Error("Method not implemented.")
+    }
+
+    /**
+    * Sets a modifier for a subsequent event emission that the event data may be lost if the client is not ready to
+    * receive messages (because of network slowness or other issues, or because they’re connected through long polling
+    * and is in the middle of a request-response cycle).
+    *
+    * @return {Socket} self
+    * @public
+    */
+    public get volatile(): Socket {
+        this.flags.volatile = true
+        return this
+    }
+
+    /**
+     * Sets a modifier for a subsequent event emission that the event data will only be broadcast to every sockets but the
+     * sender.
+     *
+     * @return {Socket} self
+     * @public
+     */
+    public get broadcast(): Socket {
+        this.flags.broadcast = true
+        return this
+    }
+
+    /**
+     * Sets a modifier for a subsequent event emission that the event data will only be broadcast to the current node.
+     *
+     * @return {Socket} self
+     * @public
+     */
+    public get local(): Socket {
+        this.flags.local = true
+        return this
+    }
+
+    /**
+     * A reference to the request that originated the underlying Engine.IO Socket.
+     *
+     * @public
+     */
+    public get request(): any {
+        return this.client.request
+    }
+
+    /**
+     * A reference to the underlying Client transport connection (Engine.IO Socket object).
+     *
+     * @public
+     */
+    public get conn() {
+        return this.client.conn
+    }
+
+    /**
+     * @public
+     */
+    public get rooms(): Set<Room> {
+        return this.adapter.socketRooms(this.id) || new Set()
+    }
+
+    /**
+     * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the
+     * callback.
+     *
+     * @param listener
+     * @public
+     */
+    public onAny(listener: (...args: any[]) => void): Socket {
+        this._anyListeners = this._anyListeners || []
+        this._anyListeners.push(listener)
+        return this
+    }
+
+    /**
+     * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the
+     * callback. The listener is added to the beginning of the listeners array.
+     *
+     * @param listener
+     * @public
+     */
+    public prependAny(listener: (...args: any[]) => void): Socket {
+        this._anyListeners = this._anyListeners || []
+        this._anyListeners.unshift(listener)
+        return this
+    }
+
+    /**
+     * Removes the listener that will be fired when any event is emitted.
+     *
+     * @param listener
+     * @public
+     */
+    public offAny(listener?: (...args: any[]) => void): Socket {
+        if (!this._anyListeners) {
+            return this
+        }
+        if (listener) {
+            const listeners = this._anyListeners
+            for (let i = 0; i < listeners.length; i++) {
+                if (listener === listeners[i]) {
+                    listeners.splice(i, 1)
+                    return this
+                }
+            }
+        } else {
+            this._anyListeners = []
+        }
+        return this
+    }
+
+    /**
+     * Returns an array of listeners that are listening for any event that is specified. This array can be manipulated,
+     * e.g. to remove listeners.
+     *
+     * @public
+     */
+    public listenersAny() {
+        return this._anyListeners || []
+    }
+
+    // ==========================================
+    buildHandshake(auth): Handshake {
+        let requestUri = this.request.uri()
+        let headers = {}
+        let nativeHeaders = this.request.headers()
+        nativeHeaders.forEach(function (header) {
+            headers[header.getKey()] = header.getValue()
+        })
+        return {
+            headers: headers,
+            time: new Date() + '',
+            address: this.conn.remoteAddress + '',
+            xdomain: !!headers['origin'],
+            secure: false,
+            issued: +new Date(),
+            url: requestUri,
+            query: querystring.parse(requestUri.indexOf('?') != -1 ? requestUri.split('?')[1] : ''),
+            auth
+        }
+    }
+    packet(packet: Packet, opts: any = { preEncoded: false }) {
+        if (!opts.preEncoded) {
+            packet.nsp = this.nsp.name
+            opts.compress = false !== opts.compress
+        }
+        try {
+            this.client._packet(packet, opts)
+        } catch (error) {
+            this._onerror(error)
+        }
+    }
+    dispatch(packet: Packet, ack?: () => void) {
+        if (ack) { this.acks.set(packet.id, ack) }
         super.emit(packet.name, ...packet.data, ack)
     }
     private hasBin(obj: any) {

packages/websocket/src/tomcat/client.ts

@@ -1,45 +1,22 @@
-import { EventEmitter } from 'events'
-import { SocketIO } from '../socket-io/interfaces'
+import { Transport } from '../transport'
 
-export class TomcatClient extends EventEmitter implements SocketIO.EngineSocket {
-    private _id: string
+export class TomcatClient extends Transport {
     private session: javax.websocket.Session
 
-    server: any
-    readyState: string
-    remoteAddress: string
-    upgraded: boolean
-    request: any
-    transport: any
-
     constructor(server: any, session: javax.websocket.Session) {
-        super()
-        this.server = server
-        this.readyState = 'open'
+        super(server)
         this.remoteAddress = session + ''
-        this.upgraded = true
         this.request = {
             uri: () => `${session.getRequestURI()}`,
             headers: () => []
         }
-        this.transport = null
-
-        this.session = session
         this._id = session.getId() + ''
+        this.session = session
     }
-
-    get id() {
-        return this._id
+    doSend(text: string) {
+        Java.synchronized(() => this.session.getBasicRemote().sendText(text), this.session)()
     }
-    send(text: string) {
-        if (this.readyState == 'open') {
-            Java.synchronized(() => this.session.getBasicRemote().sendText(text), this.session)()
-        }
-    }
-    close() {
-        if (this.readyState == 'open') {
-            this.readyState = 'close'
-            this.session.close()
-        }
+    doClose() {
+        this.session.close()
     }
 }

packages/websocket/src/tomcat/index.ts

@@ -2,20 +2,17 @@ import { EventEmitter } from 'events'
 
 import { ServerOptions } from '../socket-io'
 import { ServerEvent } from '../socket-io/constants'
-import { SocketIO } from '../socket-io/interfaces'
 import { ProxyBeanName } from './constants'
 import { TomcatClient } from './client'
 
-const WebSocketServerProxy = Java.type("pw.yumc.MiaoScript.websocket.WebSocketProxy")
 const ThreadPoolExecutor = Java.type('java.util.concurrent.ThreadPoolExecutor')
-const ThreadPoolTaskExecutor = Java.type('org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor')
 
 type TomcatWebSocketSession = javax.websocket.Session
 
 class TomcatWebSocketServer extends EventEmitter {
     private beanFactory: any
     private executor: any
-    private clients: Map<string, SocketIO.EngineSocket>
+    private clients: Map<string, any>
 
     constructor(beanFactory: any, options: ServerOptions) {
         super()
@@ -23,7 +20,7 @@ class TomcatWebSocketServer extends EventEmitter {
         this.beanFactory = beanFactory
         this.initThreadPool()
         try { this.beanFactory.destroySingleton(ProxyBeanName) } catch (error) { }
-        let NashornWebSocketServerProxy = Java.extend(WebSocketServerProxy, {
+        let NashornWebSocketServerProxy = Java.extend(Java.type("pw.yumc.MiaoScript.websocket.WebSocketProxy"), {
             onOpen: (session: TomcatWebSocketSession) => {
                 let cid = `${session?.getId()}`
                 let tomcatClient = new TomcatClient(this, session)
@@ -59,6 +56,7 @@ class TomcatWebSocketServer extends EventEmitter {
         this.beanFactory.registerSingleton(ProxyBeanName, new NashornWebSocketServerProxy())
     }
     private initThreadPool() {
+        const ThreadPoolTaskExecutor = Java.type('org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor')
         this.executor = new ThreadPoolTaskExecutor()
         this.executor.setCorePoolSize(10)
         this.executor.setMaxPoolSize(100)
@@ -77,6 +75,5 @@ class TomcatWebSocketServer extends EventEmitter {
 
 export {
     TomcatWebSocketServer,
-    ServerEvent,
     TomcatClient
 }

packages/websocket/src/transport.ts

@@ -0,0 +1,35 @@
+import { EventEmitter } from 'events'
+
+export abstract class Transport extends EventEmitter {
+    protected _id: string
+
+    server: any
+    readyState: 'opening' | 'open' | 'closing' | 'closed'
+    remoteAddress: string
+    upgraded: boolean
+    request: any
+
+    constructor(server: any) {
+        super()
+        this.server = server
+        this.readyState = 'open'
+        this.upgraded = true
+    }
+    get id() {
+        return this._id
+    }
+    send(text: string) {
+        if (this.readyState == 'open') {
+            this.doSend(text)
+        } else {
+            console.debug(`send message ${text} to close client ${this._id}`)
+        }
+    }
+    close() {
+        if ("closed" === this.readyState || "closing" === this.readyState) { return }
+        this.doClose()
+        this.readyState = 'closed'
+    }
+    abstract doSend(text: string)
+    abstract doClose()
+}