@vyr/service-scene 0.0.1

package/package.json

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

package/src/SceneMethodProvider.ts

@@ -0,0 +1,129 @@
+import { ArrayUtils, AsyncTask, Category, Descriptor } from "@vyr/engine"
+import { DataService, runtime } from "@vyr/runtime"
+import { Message, RpcService } from '@vyr/service-rpc'
+import { SceneService } from "./SceneService"
+
+class SceneMethodProvider {
+    readonly ready = new AsyncTask()
+    readonly service
+
+    constructor(service: SceneService) {
+        this.service = service
+    }
+
+    listen() {
+        const rpcService = runtime.get<RpcService>('rpc')
+        rpcService.listen(Message.rpc.connection.Method, this._connection)
+        rpcService.listen(Message.rpc.disconnect.Method, this._disconnect)
+        rpcService.listen(Message.scene.initialize.Method, this._initialize)
+        rpcService.listen(Message.scene.record.Method, this._record)
+        rpcService.listen(Message.scene.create.Method, this._create)
+        rpcService.listen(Message.scene.delete.Method, this._delete)
+        rpcService.listen(Message.scene.switch.Method, this._switch)
+        rpcService.listen(Message.scene.add.Method, this._add)
+        rpcService.listen(Message.scene.remove.Method, this._remove)
+        rpcService.listen(Message.scene.dragdrap.Method, this._dragdrap)
+        rpcService.listen(Message.scene.update.Method, this._update)
+    }
+
+    _connection = (msg: InstanceType<typeof Message['rpc']['connection']['NoticeMessage']>) => {
+        const urlParams = new URLSearchParams(window.location.search)
+        let url = 'default.scene.json'
+        const defaultScene = urlParams.get('scene')
+        if (defaultScene) {
+            const result = Category.parseName(defaultScene)
+            if (Category.scene === result.category) url = defaultScene
+        }
+        const rpcService = runtime.get<RpcService>('rpc')
+        rpcService.send(new Message.scene.initialize.RequestMessage(url))
+    }
+
+    _disconnect = (msg: InstanceType<typeof Message['rpc']['disconnect']['NoticeMessage']>) => {
+        this.service.useRecord.clearUser(msg.params.client)
+    }
+
+    _initialize = async (msg: InstanceType<typeof Message['scene']['initialize']['NoticeMessage']>) => {
+        const { params } = msg
+        const descriptor = Descriptor.create(params.serialization)
+        this.service.root.clear()
+        this.service.root.add(descriptor)
+        this.service.scenes.length = 0
+        this.service.scenes.push(...params.scenes)
+        this.service.navigator.url = params.url
+        this.ready.run()
+    }
+
+    _record = async (msg: InstanceType<typeof Message['scene']['record']['NoticeMessage']>) => {
+        this.service.useRecord.copy(msg.params.useRecord)
+    }
+
+    _create = (msg: InstanceType<typeof Message['scene']['create']['NoticeMessage']>) => {
+        ArrayUtils.insert(this.service.scenes, msg.params.url)
+    }
+
+    _delete = (msg: InstanceType<typeof Message['scene']['delete']['NoticeMessage']>) => {
+        ArrayUtils.remove(this.service.scenes, msg.params.url)
+        this.service.useRecord.clear(msg.params.url)
+    }
+
+    _switch = async (msg: InstanceType<typeof Message['scene']['switch']['NoticeMessage']>) => {
+        this.service.useRecord.removeUser(msg.params.url.old, msg.params.client)
+        this.service.useRecord.addUser(msg.params.url.new, msg.params.client)
+        const rpcService = runtime.get<RpcService>('rpc')
+        if (msg.params.client !== rpcService.client) return
+
+        this.service.navigator.url = msg.params.url.new
+        this.service.root.clear()
+        const descriptor = Descriptor.create(msg.params.serialization)
+        this.service.root.add(descriptor)
+    }
+
+    _add = (msg: InstanceType<typeof Message['scene']['add']['NoticeMessage']>) => {
+        const parent = Descriptor.get<Descriptor>(msg.params.parent)
+        if (parent === null) return
+
+        if (msg.params.next) {
+            for (const item of msg.params.node) {
+                const node = Descriptor.create(item)
+                parent.insertBefore(node.uuid, msg.params.next)
+            }
+        } else {
+            for (const item of msg.params.node) {
+                const node = Descriptor.create(item)
+                parent.add(node)
+            }
+        }
+    }
+
+    _remove = (msg: InstanceType<typeof Message['scene']['remove']['NoticeMessage']>) => {
+        for (const uuid of msg.params.uuids) {
+            const target = Descriptor.get<Descriptor>(uuid)
+            if (target === null) continue
+            const ancestor = target.traceAncestor(false)
+            if (ancestor.parent === null) continue
+            ancestor.parent.remove(target)
+
+            target.traverse(child => {
+                ArrayUtils.removeByKey(this.service.navigator.selectAll, 'uuid', child.uuid)
+                ArrayUtils.removeByKey(this.service.navigator.status.stickupItems, 'uuid', child.uuid)
+            })
+        }
+    }
+
+    _update = (msg: InstanceType<typeof Message['scene']['update']['NoticeMessage']>) => {
+        const node = Descriptor.get<Descriptor>(msg.params.content.uuid)
+        if (node === null) return
+        node.syncWith(msg.params.content)
+    }
+
+    _dragdrap = (msg: InstanceType<typeof Message['scene']['dragdrap']['NoticeMessage']>) => {
+        const method = msg.params.next ? 'insertBefore' : msg.params.type
+        const target = msg.params.next || msg.params.targetData.data.uuid
+
+        for (const uuid of msg.params.dragData.data.uuids) {
+            this.service.root[method](uuid, target)
+        }
+    }
+}
+
+export { SceneMethodProvider }

package/src/SceneService.ts

@@ -0,0 +1,78 @@
+import axios from 'axios'
+import { Service } from '@vyr/service'
+import { DraggableData, DraggableEndType, } from '@vyr/declare'
+import { Descriptor, DeserializationObject } from '@vyr/engine'
+import { runtime, SidebarNavigator } from '@vyr/runtime'
+import { Message, RpcService, UseRecord } from '@vyr/service-rpc'
+import { SceneMethodProvider } from './SceneMethodProvider'
+
+class SceneService extends Service {
+    private _provider = new SceneMethodProvider(this)
+    readonly root
+    readonly useRecord
+    readonly navigator
+    readonly scenes: string[] = []
+
+    constructor(name: string, useRecord: UseRecord, root: Descriptor, navigator: SidebarNavigator) {
+        super(name)
+        this.root = root
+        this.useRecord = useRecord
+        this.navigator = navigator
+    }
+
+    async ready() {
+        this._provider.listen()
+    }
+
+    async start() {
+        await this._provider.ready.done()
+    }
+
+    create(url: string) {
+        const rpcService = runtime.get<RpcService>('rpc')
+        rpcService.send(new Message.scene.create.RequestMessage(url))
+    }
+
+    delete(url: string) {
+        const rpcService = runtime.get<RpcService>('rpc')
+        rpcService.send(new Message.scene.delete.RequestMessage(url))
+    }
+
+    switch(url: string) {
+        const rpcService = runtime.get<RpcService>('rpc')
+        rpcService.send(new Message.scene.switch.RequestMessage(url))
+    }
+
+    add(node: DeserializationObject<Descriptor>[], parent: string) {
+        const rpcService = runtime.get<RpcService>('rpc')
+        rpcService.send(new Message.scene.add.RequestMessage(node, parent))
+    }
+
+    remove(uuids: string[]) {
+        const rpcService = runtime.get<RpcService>('rpc')
+        rpcService.send(new Message.scene.remove.RequestMessage(uuids))
+    }
+
+    dragdrap(type: DraggableEndType, dragData: DraggableData<{ uuids: string[] }>, targetData: DraggableData<{ uuid: string }>) {
+        const rpcService = runtime.get<RpcService>('rpc')
+        rpcService.send(new Message.scene.dragdrap.RequestMessage(type, dragData, targetData))
+    }
+
+    update(content: DeserializationObject<Descriptor>) {
+        const rpcService = runtime.get<RpcService>('rpc')
+        rpcService.send(new Message.scene.update.RequestMessage(content))
+    }
+
+    async download(scene?: string) {
+        const res = await axios.get(Message.scene.download.Method, { params: new Message.scene.download.RequestMessage(scene), responseType: 'blob' })
+
+        const url = URL.createObjectURL(res.data)
+        const download = document.createElement('a')
+        download.href = url
+        download.download = 'project.zip'
+        download.click()
+        URL.revokeObjectURL(url)
+    }
+}
+
+export { SceneService }

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from './locale'
+export { SceneService } from './SceneService'

package/src/locale/Language.ts

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

package/src/locale/LanguageProvider.ts

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

package/src/locale/index.ts

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