@vyr/remote 0.0.1

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@vyr/remote",
+  "version": "0.0.1",
+  "description": "",
+  "main": "./src/index.ts",
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "dom-to-image": "^2.6.0",
+    "@vyr/locale": "0.0.1",
+    "@vyr/declare": "0.0.1",
+    "@vyr/engine": "0.0.1"
+  },
+  "files": [
+    "package.json",
+    "src/"
+  ]
+}

package/src/Bridge.ts

@@ -0,0 +1,133 @@
+import { AsyncTask, Descriptor, Listener } from "@vyr/engine"
+import { Job } from "./job"
+
+interface RemoteConfig {
+  /**代理的唯一标识 */
+  id: string
+  /**远程服务的运行环境 */
+  env: 'window' | 'iframe'
+  /**远程服务是否执行任务 */
+  execute: boolean
+  /**是否启用远程服务的调用功能 */
+  invoke: boolean
+  /**远程服务运行后立即渲染的场景 */
+  scene?: string
+}
+
+interface BridgeConfig {
+  id: string
+  args?: any[]
+  useRemote?: () => Promise<Window>
+  autoConnect?: boolean
+}
+
+interface BridgeListener {
+  keydown: (event: KeyboardEvent) => void
+  keyup: (event: KeyboardEvent) => void
+  mouseup: (event: MouseEvent) => void
+  close: (args: {}) => void
+}
+
+/**
+ * 用于在远程环境之间传递信息的桥梁
+ */
+class Bridge {
+  static readonly key = '__VYR_RUNTIME_REMOTE'
+  static createBaseUrl() {
+    const { protocol, hostname, port } = window.location
+    return `${protocol}//${hostname}:${port}`
+  }
+  private _id
+  private _args
+  private _remote!: Window
+  private _closeId = -1
+  private _readyId = -1
+  private _listener = new Listener<BridgeListener>()
+  connected = new AsyncTask()
+  comm
+
+  constructor(config: BridgeConfig) {
+    this._id = config.id
+    this._args = config.args ?? []
+    this.comm = Bridge.createBaseUrl()
+    window.addEventListener('message', this.onReceive)
+    window.addEventListener('beforeunload', () => this.send(new Job.bridge.disconnect.Response({})))
+    if (config.useRemote) config.useRemote().then(this.checkReady)
+  }
+
+  private pipe = (remote: Window, message: Job) => {
+    remote.postMessage({ key: Bridge.key, id: this._id, message: Descriptor.serialization(message) }, this.comm)
+  }
+
+  private checkReady = (remote: Window) => {
+    if (this._remote) return
+    clearTimeout(this._readyId)
+    //@ts-ignore
+    this._readyId = setTimeout(() => this.checkReady(remote), 1000)
+    this.pipe(remote, new Job.bridge.connection.Response({}))
+  }
+
+  private isBridgeMessage = (event: MessageEvent) => {
+    return event.data.key === Bridge.key && event.data.id === this._id
+  }
+  private checkWindowClosed = () => {
+    if (this._remote.closed === false) return
+    this._listener.trigger('close', {})
+  }
+  private onDisconnect = () => {
+    clearTimeout(this._closeId)
+    this._closeId = setTimeout(this.checkWindowClosed, 5000) as unknown as number
+    this.connected = new AsyncTask()
+    const remote = this._remote
+    //@ts-ignore
+    this._remote = null
+    this.checkReady(remote)
+  }
+  private onReceive = (event: MessageEvent) => {
+    if (this.isBridgeMessage(event) === false) return
+    const task = Descriptor.deserialization<Job>(event.data.message)
+    switch (task.method) {
+      case Job.bridge.connection.Method:
+        clearTimeout(this._readyId)
+        this._remote = event.source as Window
+        this.connected.run()
+        const params = task.params as { stop?: boolean }
+        if (params.stop === undefined) {
+          this.send(new Job.bridge.connection.Response({ stop: true }))
+        }
+        break;
+      case Job.bridge.disconnect.Method:
+        this.onDisconnect()
+        break;
+      default:
+        this._listener.trigger(task.method, task, ...this._args)
+        break;
+    }
+  }
+
+  listen<T extends keyof BridgeListener>(method: T, cb: BridgeListener[T]): void
+  listen(method: string, cb: (...args: any[]) => void): void
+  listen(method: string, cb: (...args: any[]) => void) {
+    this._listener.listen(method, cb)
+  }
+
+  unlisten<T extends keyof BridgeListener>(method: T, cb: BridgeListener[T]): void
+  unlisten(method: string, cb: (...args: any[]) => void): void
+  unlisten(method: string, cb: (...args: any[]) => void) {
+    this._listener.unlisten(method, cb)
+  }
+
+  async send(message: Job) {
+    const serialization = Descriptor.serialization(message)
+    await this.connected.done()
+    this._remote.postMessage({ key: Bridge.key, id: this._id, message: serialization }, this.comm)
+  }
+
+  async close() {
+    await this.connected.done()
+    this._remote.close()
+    this._listener.trigger('close', {})
+  }
+}
+
+export { RemoteConfig, Bridge }

package/src/ChangeScriptable.ts

@@ -0,0 +1,22 @@
+import { Descriptor, Graphics, HTMLTransformControllerChangeArgs, HTMLTransformControllerDescriptor, Scriptable } from "@vyr/engine";
+import { RemoteProcess } from "./RemoteProcess";
+import { Job } from "./job";
+
+class ChangeScriptable extends Scriptable {
+
+    execute(descriptor: HTMLTransformControllerDescriptor, graphics: Graphics, args: HTMLTransformControllerChangeArgs) {
+        const process = RemoteProcess.get(graphics.engine)
+        if (process === null) return
+
+        if (args.event.type === 'contextmenu') {
+            process.bridge.send(new Job.invoke.pick.Response({ descriptor: '' }))
+        } else {
+            const target = Descriptor.get(args.event.target) as Descriptor
+            if (target === null) return
+            const params = { eventType: args.event.type, target: args.event.target, descriptor: target.clone(false) }
+            process.bridge.send(new Job.invoke.transform.Response(params))
+        }
+    }
+}
+
+export default ChangeScriptable

package/src/Collection.ts

@@ -0,0 +1,36 @@
+interface Item {
+    [k: string]: any
+}
+
+class Collection {
+    private instance = new Map<Item, Item>()
+    private map = new Map<Item, Item>()
+
+    set(key: Item, value: Item) {
+        this.instance.set(key, value)
+        this.map.set(value, key)
+    }
+
+    get<T extends Item = Item>(key: Item) {
+        return (this.instance.get(key) ?? null) as T | null
+    }
+
+    getByMap<T extends Item = Item>(key: Item) {
+        return (this.map.get(key) ?? null) as T | null
+    }
+
+    delete(key: Item) {
+        const value = this.instance.get(key)
+        if (value === undefined) return
+        this.instance.delete(key)
+        this.map.delete(value)
+    }
+
+    values<T extends Item = Item>() {
+        return [...this.instance.values()] as T[]
+    }
+}
+
+export {
+    Collection
+}