@vyr/service-asset 0.0.1

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@vyr/service-asset",
+  "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/service": "0.0.1",
+    "@vyr/runtime": "0.0.1",
+    "@vyr/engine": "0.0.1",
+    "@vyr/service-rpc": "0.0.1"
+  },
+  "files": [
+    "package.json",
+    "src/"
+  ]
+}

package/src/AssetMethodProvider.ts

@@ -0,0 +1,132 @@
+import { ArrayUtils, AsyncTask, Descriptor } from "@vyr/engine"
+import { DataService, runtime } from "@vyr/runtime"
+import { Message, RpcService, VirtualNode } from '@vyr/service-rpc'
+import { AssetService } from "./AssetService"
+
+class AssetMethodProvider {
+    readonly ready = new AsyncTask()
+    readonly service
+
+    constructor(service: AssetService) {
+        this.service = service
+    }
+
+    private _clear(items: Descriptor[], item: VirtualNode) {
+        if (items.length === 0) return
+        for (const stickupItem of items) {
+            if (stickupItem.uuid !== item.uuid) continue
+            ArrayUtils.remove(items, stickupItem)
+            return
+        }
+    }
+
+    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.asset.initialize.Method, this._initialize)
+        rpcService.listen(Message.asset.create.Method, this._create)
+        rpcService.listen(Message.asset.delete.Method, this._delete)
+        rpcService.listen(Message.asset.add.Method, this._add)
+        rpcService.listen(Message.asset.remove.Method, this._remove)
+        rpcService.listen(Message.asset.open.Method, this._open)
+        rpcService.listen(Message.asset.close.Method, this._close)
+        rpcService.listen(Message.asset.update.Method, this._update)
+        rpcService.listen(Message.asset.dragdrap.Method, this._dragdrap)
+    }
+
+    _connection = async (msg: InstanceType<typeof Message['rpc']['connection']['NoticeMessage']>) => {
+        const rpcService = runtime.get<RpcService>('rpc')
+        rpcService.send(new Message.asset.initialize.RequestMessage())
+    }
+
+    _disconnect = (msg: InstanceType<typeof Message['rpc']['disconnect']['NoticeMessage']>) => {
+        this.service.root.clearUser(msg.params.client)
+    }
+
+    _initialize = (msg: InstanceType<typeof Message['asset']['initialize']['NoticeMessage']>) => {
+        this.service.root.clear()
+        for (const sub of msg.params.root.children) this.service.root.add(new VirtualNode(sub))
+        this.ready.run()
+    }
+
+    _open = (msg: InstanceType<typeof Message['asset']['open']['NoticeMessage']>) => {
+        const asset = VirtualNode.get<VirtualNode>(msg.params.url)
+        if (asset) asset.addUser(msg.params.client)
+    }
+
+    _close = (msg: InstanceType<typeof Message['asset']['close']['NoticeMessage']>) => {
+        const asset = VirtualNode.get<VirtualNode>(msg.params.url)
+        if (asset) asset.removeUser(msg.params.client)
+    }
+
+    _create = (msg: InstanceType<typeof Message['asset']['create']['NoticeMessage']>) => {
+        const asset = VirtualNode.get<VirtualNode>(msg.params.parent)
+        if (asset === null) return
+        asset.add(new VirtualNode(VirtualNode.deserialization(msg.params.node)))
+        asset.sort()
+    }
+
+    _delete = (msg: InstanceType<typeof Message['asset']['delete']['NoticeMessage']>) => {
+        const dataService = runtime.get<DataService>('data')
+        for (const path of msg.params.urls) {
+            const node = VirtualNode.get<VirtualNode>(path)
+            if (node === null) return
+            const ancestor = node.traceAncestor<VirtualNode>(false)
+            if (ancestor.parent === null) continue
+
+            this._clear(dataService.footer.status.stickupItems, node)
+            ancestor.parent.remove(node)
+        }
+    }
+
+    _add = (msg: InstanceType<typeof Message['asset']['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['asset']['remove']['NoticeMessage']>) => {
+        const dataService = runtime.get<DataService>('data')
+
+        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)
+
+            ArrayUtils.removeByKey(this.service.navigator.selectAll, 'uuid', target.uuid)
+            ArrayUtils.removeByKey(this.service.navigator.status.stickupItems, 'uuid', target.uuid)
+        }
+    }
+
+    _update = (msg: InstanceType<typeof Message['asset']['update']['NoticeMessage']>) => {
+        const descriptor = Descriptor.get<Descriptor>(msg.params.content.uuid)
+        if (descriptor) descriptor.syncWith(msg.params.content)
+    }
+
+    _dragdrap = (msg: InstanceType<typeof Message['asset']['dragdrap']['NoticeMessage']>) => {
+        if (msg.params.url !== this.service.navigator.url) return
+
+        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 { AssetMethodProvider }

package/src/AssetService.ts

@@ -0,0 +1,102 @@
+import axios from 'axios'
+import { Service } from '@vyr/service'
+import { DraggableData, DraggableEndType, } from '@vyr/declare'
+import { runtime, SidebarNavigator } from '@vyr/runtime'
+import { Descriptor, DeserializationObject } from '@vyr/engine'
+import { RpcService, Message, VirtualNode } from '@vyr/service-rpc'
+import { AssetMethodProvider } from "./AssetMethodProvider"
+
+class AssetService extends Service {
+    private _provider = new AssetMethodProvider(this)
+    readonly navigator
+    readonly root
+
+    constructor(name: string, root: VirtualNode, navigator: SidebarNavigator) {
+        super(name)
+        this.name = name
+        this.root = root
+        this.navigator = navigator
+    }
+
+    async ready() {
+        this._provider.listen()
+    }
+
+    async start() {
+        await this._provider.ready.done()
+    }
+
+    select(path: string) {
+        const rpcService = runtime.get<RpcService>('rpc')
+        rpcService.send(new Message.asset.select.RequestMessage(path))
+    }
+
+    open(path: string) {
+        const rpcService = runtime.get<RpcService>('rpc')
+        rpcService.send(new Message.asset.open.RequestMessage(path))
+    }
+
+    close(path: string) {
+        const rpcService = runtime.get<RpcService>('rpc')
+        rpcService.send(new Message.asset.close.RequestMessage(path))
+    }
+
+    /**新增文件 */
+    create(fileType: boolean, name: string, suffix: string, parent: string, content: string) {
+        const rpcService = runtime.get<RpcService>('rpc')
+        rpcService.send(new Message.asset.create.RequestMessage(fileType, name, suffix, parent, content))
+    }
+
+    /**删除文件 */
+    delete(path: string[] | string) {
+        const requestData = Array.isArray(path) ? path : [path]
+        if (requestData.length === 0) return
+        const rpcService = runtime.get<RpcService>('rpc')
+        rpcService.send(new Message.asset.delete.RequestMessage(requestData))
+    }
+
+    add(path: string, node: DeserializationObject<Descriptor>[], parent: string) {
+        const rpcService = runtime.get<RpcService>('rpc')
+        rpcService.send(new Message.asset.add.RequestMessage(path, parent, node))
+    }
+
+    remove(path: string, uuids: string[]) {
+        const rpcService = runtime.get<RpcService>('rpc')
+        rpcService.send(new Message.asset.remove.RequestMessage(path, uuids))
+    }
+
+    dragdrap(path: string, type: DraggableEndType, dragData: DraggableData<{ uuids: string[] }>, targetData: DraggableData<{ uuid: string }>) {
+        const rpcService = runtime.get<RpcService>('rpc')
+        rpcService.send(new Message.asset.dragdrap.RequestMessage(path, type, dragData, targetData))
+    }
+
+    rename(path: string, newName: string) {
+        const rpcService = runtime.get<RpcService>('rpc')
+        rpcService.send(new Message.asset.rename.RequestMessage(newName, path))
+    }
+
+    /**剪切文件,将文件移动到指定目录 */
+    cut(path: string[], target: string) {
+        if (path.length === 0) return
+        const rpcService = runtime.get<RpcService>('rpc')
+        rpcService.send(new Message.asset.cut.RequestMessage(path, target))
+    }
+
+    /**复制文件 */
+    copy(path: string[], target: string) {
+        if (path.length === 0) return
+        const rpcService = runtime.get<RpcService>('rpc')
+        rpcService.send(new Message.asset.copy.RequestMessage(path, target))
+    }
+    update(path: string, content: DeserializationObject<Descriptor>) {
+        const rpcService = runtime.get<RpcService>('rpc')
+        rpcService.send(new Message.asset.update.RequestMessage(path, content))
+    }
+
+    async read(url: string) {
+        const res = await axios.get<string>(url, { responseType: 'text' })
+        return res.data
+    }
+}
+
+export { AssetService }

package/src/index.ts

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

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-asset',
+}
+
+export {
+    ZhCNLanguageProvider,
+    zhCnLanguageProvider,
+}

package/src/locale/index.ts

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