@vyr/engine 0.0.1 → 0.0.3

package/src/interpreter/StyleInterpreter.ts

@@ -1,4 +1,4 @@
-import { Descriptor, StyleDescriptor, UpdateArgs } from "../descriptor";
+import { Descriptor, StyleDescriptor } from "../descriptor";
 import { StyleActor } from "../actor";
 import { Graphics, Unit } from "../graphics";
 import { Interpreter } from "./Interpreter";
@@ -27,14 +27,14 @@ class StyleInterpreter extends Interpreter {
         this.className = `vyr_${unit.uuid}`
     }
 
-    protected createActor(descriptor: StyleDescriptor, args: UpdateArgs) {
+    protected createActor(descriptor: StyleDescriptor) {
         return new StyleActor()
     }
 
-    update(descriptor: StyleDescriptor, args: UpdateArgs) {
-        super.update(descriptor, args)
+    update(descriptor: StyleDescriptor) {
+        super.update(descriptor)
 
-        const actor = this.getActor<StyleActor>(descriptor, args)
+        const actor = this.getActor<StyleActor>(descriptor)
         actor.update(descriptor, this.className)
 
         if (actor.updateRule(StyleInterpreter.sheet) === true) return
@@ -43,7 +43,7 @@ class StyleInterpreter extends Interpreter {
         StyleInterpreter.insertRule(styleValues)
     }
 
-    free(descriptor: Descriptor, args: UpdateArgs) {
+    free(descriptor: Descriptor) {
         const selectorTexts = [`.${this.className}`, `.${this.className}:hover`]
         for (let i = StyleInterpreter.sheet.cssRules.length - 1; i >= 0; i--) {
             const rule = StyleInterpreter.sheet.cssRules[i]
@@ -56,7 +56,7 @@ class StyleInterpreter extends Interpreter {
                 }
             }
         }
-        super.free(descriptor, args)
+        super.free(descriptor)
     }
 }
 Interpreter.register(StyleInterpreter)

package/src/interpreter/index.ts

@@ -4,7 +4,6 @@ export * from './StyleInterpreter'
 export * from './AnimationUnitInterpreter'
 export * from './FragmentInterpreter'
 export * from './DynamicInterpreter'
-export * from './RoutineInterpreter'
 export * from './PrefaInterpreter'
 export * from './PrefabInstanceInterpreter'
 export * from "./DivInterpreter";

package/src/locale/LanguageProvider.ts

@@ -14,8 +14,9 @@ interface ZhCNLanguageProvider extends LanguageProvider {
     'graphics.unit.notFound': string
     'engine.run.container.notFound': string
 
-    '/virtual:/preset/net/request.ts': string
+    '/virtual:/preset/net/http.ts': string
     '/virtual:/preset/dataset/update.ts': string
+    '/virtual:/preset/dataset/compile.ts': string
     '/virtual:/preset/scheduler/switch.ts': string
     '/virtual:/preset/graphics/invoke.ts': string
 }
@@ -36,8 +37,9 @@ const zhCnLanguageProvider: ZhCNLanguageProvider = {
     'graphics.unit.notFound': '单元不存在：{{uuid}}',
     'engine.run.container.notFound': '挂载节点不存在',
 
-    '/virtual:/preset/net/request.ts': '网络请求',
+    '/virtual:/preset/net/http.ts': '网络请求',
     '/virtual:/preset/dataset/update.ts': '更新数据集',
+    '/virtual:/preset/dataset/compile.ts': '组合数据集',
     '/virtual:/preset/scheduler/switch.ts': '切换场景',
     '/virtual:/preset/graphics/invoke.ts': '调用交互',
 }

package/src/preset/execute/dataset/compile.ts

@@ -0,0 +1,99 @@
+import { language } from "../../../locale";
+import { Asset } from "../../../asset";
+import { InteractionNode, Scriptable, ScriptableArgs } from "../../../interaction";
+import { DatasetDescriptor, Descriptor, HttpDataConfig } from "../../../descriptor";
+import { Graphics } from "../../../graphics";
+import { ExecuteScriptable as HttpScriptable } from "../net/http";
+
+const scriptable = Asset.createVirtualUrl('preset/dataset/compile.ts')
+class ExecuteScriptable extends Scriptable {
+
+    async getData(config: HttpDataConfig, http: HttpScriptable, trigger: Descriptor, graphics: Graphics) {
+        const args: ScriptableArgs = {
+            input: {
+                previous: '',
+                user: {
+                    type: { value: config.type },
+                    url: { value: config.url },
+                    data: { value: '' },
+                },
+                default: {}
+            },
+            result: new Map(),
+            trigger: trigger
+        }
+
+        const data = await http.execute(graphics, args)
+
+        return this.transformData(data, config)
+    }
+
+    transformData(data: any, config: HttpDataConfig) {
+        return data
+    }
+
+    async execute(graphics: Graphics, args: ScriptableArgs) {
+        const { trigger } = args
+
+        if (trigger instanceof DatasetDescriptor && trigger.dataConfigs.length > 0) {
+            const dataConfigs = trigger.dataConfigs as HttpDataConfig[]
+            const http = new HttpScriptable(Asset.createVirtualUrl('preset/dataset/compile/http.ts'))
+
+            let mergeData: any[] | any
+            if (dataConfigs.length === 1) {
+                const config = dataConfigs[0]
+                const finalData = await this.getData(config, http, trigger, graphics)
+                mergeData = config.key ? { [config.key]: finalData } : finalData
+            } else {
+                const keys = new Set<string>()
+                const queue: Promise<any>[] = []
+                for (const config of dataConfigs) {
+                    keys.add(config.key)
+
+                    const task = this.getData(config, http, trigger, graphics).then(finalData => {
+                        const first = keys.values().next().value
+                        if (keys.size === 1 && (first === '' || first === undefined)) {
+                            if (!mergeData) mergeData = []
+                            mergeData.push(finalData)
+                        } else {
+                            if (!mergeData) mergeData = {}
+                            mergeData[config.key] ? Object.assign(mergeData[config.key], finalData) : mergeData[config.key] = finalData
+                        }
+                    })
+                    queue.push(task)
+                }
+                await Promise.all(queue)
+            }
+
+            trigger.setData(mergeData)
+        }
+    }
+}
+Asset.provider(scriptable, async () => ({ default: ExecuteScriptable }))
+
+const createExecuteInput = (args: any = {}) => {
+    const input = {
+    }
+
+    return input
+}
+
+const createExecuteNode = (options: { id: string; position?: any; input?: any }) => {
+    const executeNode: InteractionNode = {
+        id: options.id,
+        label: language.get(scriptable as any),
+        position: { x: options?.position?.x ?? 20, y: options?.position?.y ?? 20 },
+        interaction: 'Execute',
+        url: scriptable,
+        input: createExecuteInput(options.input)
+    }
+    return executeNode
+}
+
+export {
+    scriptable,
+    createExecuteInput,
+    createExecuteNode,
+}
+
+

package/src/preset/execute/dataset/index.ts

@@ -1 +1,2 @@
-export * as update from './update'
+export * as update from './update'
+export * as compile from './compile'

package/src/preset/execute/dataset/update.ts

@@ -1,16 +1,15 @@
 import { language } from "../../../locale";
 import { Asset } from "../../../asset";
-import { DatasetDescriptor, Descriptor, RoutineNode, UpdateArgs } from "../../../descriptor";
+import { DatasetDescriptor } from "../../../descriptor";
+import { InteractionNode, Scriptable, ScriptableArgs } from "../../../interaction";
 import { Graphics } from "../../../graphics";
-import { Scriptable } from "../../../Scriptable";
 import { Category } from "../../../Category";
 
 const scriptable = Asset.createVirtualUrl('preset/dataset/update.ts')
 class ExecuteScriptable extends Scriptable {
-    async execute(descriptor: Descriptor, graphics: Graphics, args: UpdateArgs) {
-        //@ts-ignore
+    async execute(graphics: Graphics, args: ScriptableArgs) {
         const { input, result } = args
-        const dataset = input?.user?.url.value ?? input.default.url.value
+        const dataset = input?.user?.dataset.value ?? input.default.dataset.value
 
         const previous = result.get(input.previous)
         const datasetDescriptor = Asset.get<DatasetDescriptor>(dataset)
@@ -25,18 +24,18 @@ Asset.provider(scriptable, async () => ({ default: ExecuteScriptable }))
 
 const createExecuteInput = (args: any = {}) => {
     const input = {
-        url: { value: args.url ?? '', type: Category.dataset }
+        dataset: { value: args.dataset ?? '', type: Category.dataset }
     }
 
     return input
 }
 
 const createExecuteNode = (options: { id: string; position?: any; input?: any }) => {
-    const executeNode: RoutineNode = {
+    const executeNode: InteractionNode = {
         id: options.id,
         label: language.get(scriptable as any),
         position: { x: options?.position?.x ?? 20, y: options?.position?.y ?? 20 },
-        routine: 'Execute',
+        interaction: 'Execute',
         url: scriptable,
         input: createExecuteInput(options.input)
     }

package/src/preset/execute/graphics/invoke.ts

@@ -1,13 +1,12 @@
 import { language } from "../../../locale";
 import { Asset } from "../../../asset";
-import { Descriptor, RoutineNode, UpdateArgs } from "../../../descriptor";
+import { Descriptor } from "../../../descriptor";
+import { InteractionNode, Scriptable, ScriptableArgs } from "../../../interaction";
 import { Graphics } from "../../../graphics";
-import { Scriptable } from "../../../Scriptable";
 
 const scriptable = Asset.createVirtualUrl('preset/graphics/invoke.ts')
 class ExecuteScriptable extends Scriptable {
-    async execute(descriptor: Descriptor, graphics: Graphics, args: UpdateArgs) {
-        //@ts-ignore
+    async execute(graphics: Graphics, args: ScriptableArgs) {
         const { input } = args
         const interaction = input?.user?.interaction.value ?? input.default.interaction.value
         const target = input?.user?.target.value ?? input.default.target.value
@@ -29,11 +28,11 @@ const createExecuteInput = (args: any = {}) => {
 }
 
 const createExecuteNode = (options: { id: string; position?: any; input?: any }) => {
-    const executeNode: RoutineNode = {
+    const executeNode: InteractionNode = {
         id: options.id,
         label: language.get(scriptable as any),
         position: { x: options?.position?.x ?? 20, y: options?.position?.y ?? 20 },
-        routine: 'Execute',
+        interaction: 'Execute',
         url: scriptable,
         input: createExecuteInput(options.input)
     }

package/src/preset/execute/net/{request.ts → http.ts}

@@ -1,21 +1,14 @@
 import { language } from "../../../locale";
 import { Asset } from "../../../asset";
-import { Descriptor, RoutineNode, UpdateArgs } from "../../../descriptor";
+import { HttpType } from "../../../utils";
 import { Graphics } from "../../../graphics";
-import { Scriptable } from "../../../Scriptable";
+import { Scriptable, InteractionNode, ScriptableArgs } from "../../../interaction";
 
-enum RequestType {
-    GET = 'GET',
-    POST = 'POST',
-    PUT = 'PUT',
-    DELETE = 'DELETE',
-}
-
-const scriptable = Asset.createVirtualUrl('preset/net/request.ts')
+const scriptable = Asset.createVirtualUrl('preset/net/http.ts')
 class ExecuteScriptable extends Scriptable {
 
     joinUrl(url: string, requestData: any) {
-        const urlObj = new URL(url);
+        const urlObj = new URL(Asset.joinUrl(url));
 
         // 直接将requestData添加到urlObj的searchParams中
         Object.entries(requestData).forEach(([key, value]) => {
@@ -27,8 +20,7 @@ class ExecuteScriptable extends Scriptable {
         return urlObj.toString()
     }
 
-    async execute(descriptor: Descriptor, graphics: Graphics, args: UpdateArgs) {
-        //@ts-ignore
+    async execute(graphics: Graphics, args: ScriptableArgs) {
         const { input, result } = args
         let url = input?.user?.url.value ?? input.default.url.value
         const type: string = input?.user?.type.value ?? input.default.type.value
@@ -58,7 +50,7 @@ class ExecuteScriptable extends Scriptable {
             },
         }
         let res
-        if (type === RequestType.GET) {
+        if (type === HttpType.GET) {
             res = await fetch(this.joinUrl(url, requestData), config)
         } else {
             res = await fetch(url, { ...config, body: JSON.stringify(requestData) })
@@ -82,11 +74,11 @@ const createExecuteInput = (args: any = {}) => {
 }
 
 const createExecuteNode = (options: { id: string; position?: any; input?: any }) => {
-    const executeNode: RoutineNode = {
+    const executeNode: InteractionNode = {
         id: options.id,
         label: language.get(scriptable as any),
         position: { x: options?.position?.x ?? 20, y: options?.position?.y ?? 20 },
-        routine: 'Execute',
+        interaction: 'Execute',
         url: scriptable,
         input: createExecuteInput(options.input)
     }
@@ -95,7 +87,7 @@ const createExecuteNode = (options: { id: string; position?: any; input?: any })
 
 export {
     scriptable,
-    RequestType,
+    ExecuteScriptable,
     createExecuteInput,
     createExecuteNode,
 }

package/src/preset/execute/net/index.ts

@@ -1 +1 @@
-export * as request from './request'
+export * as http from './http'

package/src/preset/execute/scheduler/switch.ts

@@ -1,16 +1,16 @@
 import { language } from "../../../locale";
 import { Asset } from "../../../asset";
-import { Descriptor, RoutineNode, ServiceSchedulerDescriptor, UpdateArgs } from "../../../descriptor";
+import { ServiceSchedulerDescriptor } from "../../../descriptor";
+import { InteractionNode, Scriptable, ScriptableArgs } from "../../../interaction";
 import { Graphics } from "../../../graphics";
-import { Scriptable } from "../../../Scriptable";
 
 const scriptable = Asset.createVirtualUrl('preset/scheduler/switch.ts')
 class ExecuteScriptable extends Scriptable {
-    async execute(descriptor: Descriptor, graphics: Graphics, args: UpdateArgs) {
-        //@ts-ignore
-        const scene = args.input?.user?.url.value
+    async execute(graphics: Graphics, args: ScriptableArgs) {
+        const scene = args.input?.user?.scene.value
         if (!scene) return
         await Asset.loadAll(scene)
+        await Asset.compileDataset(scene, graphics.engine)
         const scheduler = Asset.get<ServiceSchedulerDescriptor>(scene)
         graphics.engine.switch(scheduler)
     }
@@ -19,18 +19,18 @@ Asset.provider(scriptable, async () => ({ default: ExecuteScriptable }))
 
 const createExecuteInput = (args: any = {}) => {
     const input = {
-        url: { value: args.url ?? '' },
+        scene: { value: args.scene ?? '' },
     }
 
     return input
 }
 
 const createExecuteNode = (options: { id: string; position?: any; input?: any }) => {
-    const executeNode: RoutineNode = {
+    const executeNode: InteractionNode = {
         id: options.id,
         label: language.get(scriptable as any),
         position: { x: options?.position?.x ?? 20, y: options?.position?.y ?? 20 },
-        routine: 'Execute',
+        interaction: 'Execute',
         url: scriptable,
         input: createExecuteInput(options.input)
     }

package/src/preset/index.ts

@@ -1,7 +1,7 @@
 import * as executePreset from './execute'
-import * as routinePreset from './routine'
+import * as interactionPreset from './interaction'
 
 export {
     executePreset,
-    routinePreset
+    interactionPreset
 }

package/src/preset/interaction/dataset/compile.ts

@@ -0,0 +1,27 @@
+import { Asset } from "../../../asset";
+import { InteractionDescriptor } from "../../../interaction";
+import { dataset } from "../../execute"
+
+const url = Asset.createVirtualUrl('preset/dataset/compile.interaction.json')
+const nodes = {
+    compile: 'compile'
+}
+let _currentInteraction: InteractionDescriptor | null = null
+const interactionProvider = async () => {
+    if (_currentInteraction === null) {
+        _currentInteraction = new InteractionDescriptor()
+        const compileNode = dataset.compile.createExecuteNode({ id: nodes.compile })
+        _currentInteraction.addNode([compileNode])
+        _currentInteraction.roots.push(compileNode.id)
+    }
+    return _currentInteraction
+}
+
+Asset.provider(url, interactionProvider)
+
+export {
+    url,
+    nodes,
+}
+
+

package/src/preset/interaction/dataset/index.ts

@@ -0,0 +1 @@
+export * as compile from "./compile"

package/src/preset/interaction/graphics/invoke.ts

@@ -0,0 +1,27 @@
+import { Asset } from "../../../asset";
+import { InteractionDescriptor } from "../../../interaction";
+import { graphics } from "../../execute"
+
+const url = Asset.createVirtualUrl('preset/graphics/invoke.interaction.json')
+const nodes = {
+    invoke: 'invoke'
+}
+let _currentInteraction: InteractionDescriptor | null = null
+const interactionProvider = async () => {
+    if (_currentInteraction === null) {
+        _currentInteraction = new InteractionDescriptor()
+        const invokeNode = graphics.invoke.createExecuteNode({ id: nodes.invoke })
+        _currentInteraction.addNode([invokeNode])
+        _currentInteraction.roots.push(invokeNode.id)
+    }
+    return _currentInteraction
+}
+
+Asset.provider(url, interactionProvider)
+
+export {
+    url,
+    nodes,
+}
+
+

package/src/preset/interaction/index.ts

@@ -0,0 +1,3 @@
+export * as dataset from './dataset'
+export * as scheduler from './scheduler'
+export * as graphics from './graphics'

package/src/preset/interaction/scheduler/switch.ts

@@ -0,0 +1,27 @@
+import { Asset } from "../../../asset";
+import { InteractionDescriptor } from "../../../interaction";
+import { scheduler } from "../../execute"
+
+const url = Asset.createVirtualUrl('preset/scheduler/switch.interaction.json')
+const nodes = {
+    switch: 'switch',
+}
+let _currentInteraction: InteractionDescriptor | null = null
+const interactionProvider = async () => {
+    if (_currentInteraction === null) {
+        _currentInteraction = new InteractionDescriptor()
+        const switchNode = scheduler.switch.createExecuteNode({ id: nodes.switch })
+        _currentInteraction.addNode([switchNode])
+        _currentInteraction.roots.push(switchNode.id)
+    }
+    return _currentInteraction
+}
+
+Asset.provider(url, interactionProvider)
+
+export {
+    url,
+    nodes,
+}
+
+

package/src/utils/AssetProvider.ts

@@ -1,4 +1,5 @@
-import { Descriptor, DynamicDescriptor, PrefabInstanceDescriptor, RoutineDescriptor, HTMLDescriptor, StyleDescriptor, InteractionProperty, RoutineNode } from "../descriptor"
+import { InteractionDescriptor, InteractionNode, InteractionProperty } from "../interaction"
+import { Descriptor, DynamicDescriptor, PrefabInstanceDescriptor, HTMLDescriptor, StyleDescriptor } from "../descriptor"
 import { AssetGraph, Port } from "../asset"
 import { Category } from "../Category"
 
@@ -14,7 +15,7 @@ const interactionExecutor = (interaction: InteractionProperty, path: string, por
         }
     }
 }
-const routineNodeExecutor = (node: RoutineNode, path: string, port: Port) => {
+const interactionNodeExecutor = (node: InteractionNode, path: string, port: Port) => {
     const params = Object.keys(node.input)
     for (const param of params) {
         const value = node.input[param]
@@ -29,7 +30,7 @@ const DescriptorProvider = (descriptor: Descriptor, port: Port) => {
             const interaction = descriptor.interactions[i]
             if (interaction.url) {
                 interactionExecutor(interaction, `interactions[${i}]`, port)
-                port.edges.push({ key: `interactions[${i}].url`, category: Category.routine, asset: interaction.url })
+                port.edges.push({ key: `interactions[${i}].url`, category: Category.interaction, asset: interaction.url })
             }
         }
     }
@@ -40,12 +41,12 @@ const StyleDescriptorProvider = (descriptor: StyleDescriptor, port: Port) => {
     if (descriptor.inherit) port.edges.push({ key: 'inherit', category: Category.style, asset: descriptor.inherit })
 }
 
-const RoutineDescriptorProvider = (descriptor: RoutineDescriptor, port: Port) => {
+const InteractionDescriptorProvider = (descriptor: InteractionDescriptor, port: Port) => {
     if (descriptor.nodes.length > 0) {
         for (let i = 0; i < descriptor.nodes.length; i++) {
             const node = descriptor.nodes[i]
             if (node.url) {
-                routineNodeExecutor(node, `nodes[${i}]`, port)
+                interactionNodeExecutor(node, `nodes[${i}]`, port)
                 port.edges.push({ key: `nodes[${i}].url`, category: Category.ts, asset: node.url })
             }
         }
@@ -66,7 +67,7 @@ const PrefabInstanceDescriptorProvider = (descriptor: PrefabInstanceDescriptor,
 
 AssetGraph.register(Descriptor.type, DescriptorProvider)
 AssetGraph.register(StyleDescriptor.type, StyleDescriptorProvider)
-AssetGraph.register(RoutineDescriptor.type, RoutineDescriptorProvider)
+AssetGraph.register(InteractionDescriptor.type, InteractionDescriptorProvider)
 AssetGraph.register(HTMLDescriptor.type, HTMLDescriptorProvider)
 AssetGraph.register(DynamicDescriptor.type, DynamicDescriptorProvider)
 AssetGraph.register(PrefabInstanceDescriptor.type, PrefabInstanceDescriptorProvider)

package/src/utils/constants.ts

@@ -0,0 +1,10 @@
+enum HttpType {
+    GET = 'GET',
+    POST = 'POST',
+    PUT = 'PUT',
+    DELETE = 'DELETE',
+}
+
+export {
+    HttpType
+}

package/src/utils/index.ts

@@ -1 +1,2 @@
+export * from './constants'
 export * from './AssetProvider'

package/src/Scriptable.ts

@@ -1,27 +0,0 @@
-import { Descriptor, UpdateArgs } from "./descriptor"
-import { Graphics } from "./graphics/Graphics"
-
-/**
- * 可编程脚本(脚本不会在服务端实例化)
- */
-class Scriptable {
-    readonly uuid
-    /**脚本文件的url路径 */
-    get url() {
-        return this.uuid
-    }
-
-    constructor(url: string) {
-        this.uuid = url
-    }
-
-    /**脚本的准备事件，该方法在脚本被实例化后立即执行
-     * 
-     * 一般在该事件中进行脚本的准备工作，如从服务端获取资源或数据
-     */
-    async ready() { }
-
-    execute(descriptor: Descriptor, graphics: Graphics, args: UpdateArgs): any { }
-}
-
-export { Scriptable }

package/src/descriptor/RoutineDescriptor.ts

@@ -1,54 +0,0 @@
-import { DeserializationObject } from "../Serialization";
-import { Descriptor, InteractionInput, UpdateArgs } from ".";
-
-interface RoutineNode {
-    id: string
-    label: string
-    position: { x: number; y: number }
-    routine: string
-    url: string
-    input: InteractionInput
-}
-
-interface RoutineMapper {
-    source: string
-    target: string
-}
-
-interface RoutineUpdateArgs<T = InteractionInput> extends UpdateArgs {
-    input: {
-        previous: string
-        default: T
-        user: T
-    }
-}
-
-class RoutineDescriptor extends Descriptor {
-    static type = 'Routine'
-    roots: string[]
-    nodes: RoutineNode[]
-    mappers: RoutineMapper[]
-
-    constructor(descriptor: Partial<DeserializationObject<RoutineDescriptor>> = {}) {
-        super(descriptor)
-        this.roots = descriptor.roots ? Descriptor.deepClone(descriptor.roots) : []
-        this.nodes = descriptor.nodes ? Descriptor.deepClone(descriptor.nodes) : []
-        this.mappers = descriptor.mappers ? Descriptor.deepClone(descriptor.mappers) : []
-    }
-
-    addNode(nodes: RoutineNode[]) {
-        const count = nodes.length
-        const max = count - 1
-        for (let i = 0; i < count; i++) {
-            const node = nodes[i]
-            this.nodes.push(node)
-            if (i < max) {
-                this.mappers.push({ source: node.id, target: nodes[i + 1].id })
-            }
-        }
-    }
-}
-Descriptor.register(RoutineDescriptor)
-
-
-export { RoutineNode, RoutineMapper, RoutineUpdateArgs, RoutineDescriptor }