@vyr/engine 0.0.1 → 0.0.2

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,17 +1,10 @@
 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) {
@@ -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,6 @@ const createExecuteNode = (options: { id: string; position?: any; input?: any })
 
 export {
     scriptable,
-    RequestType,
     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,14 +1,13 @@
 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)
         const scheduler = Asset.get<ServiceSchedulerDescriptor>(scene)
@@ -19,18 +18,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/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.nodes.push(invokeNode)
+        _currentInteraction.roots.push(invokeNode.id)
+    }
+    return _currentInteraction
+}
+
+Asset.provider(url, interactionProvider)
+
+export {
+    url,
+    nodes,
+}
+
+

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.nodes.push(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 }

package/src/interpreter/RoutineInterpreter.ts

@@ -1,88 +0,0 @@
-import { Asset } from "../asset";
-import { Scriptable } from "../Scriptable";
-import { RoutineDescriptor, RoutineNode, UpdateArgs, InteractionInputCollection } from "../descriptor";
-import { Interpreter } from "./Interpreter";
-
-type ExecuteResult = { [k: string]: any } | null
-
-class RoutineInterpreter extends Interpreter {
-    static type = RoutineDescriptor.type
-    readonly collection = new Map<string, RoutineNode>()
-    readonly linkCollection = new Map<string, string[]>()
-
-    update(descriptor: RoutineDescriptor, args: UpdateArgs) {
-        super.update(descriptor, args)
-
-        this.collection.clear()
-        this.linkCollection.clear()
-
-        for (const node of descriptor.nodes) {
-            this.collection.set(node.id, node)
-        }
-
-        for (const mapper of descriptor.mappers) {
-            let link = this.linkCollection.get(mapper.source)
-            if (link === undefined) {
-                link = []
-                this.linkCollection.set(mapper.source, link)
-            }
-            link.push(mapper.target)
-        }
-    }
-
-    async doBranch(branch: string, previous: string, customInputs: InteractionInputCollection, descriptor: RoutineDescriptor, args: UpdateArgs, result: Map<string, ExecuteResult>) {
-        this.doExecute(branch, previous, customInputs, descriptor, args, result)
-    }
-
-    async doCondition(condition: string, previous: string, customInputs: InteractionInputCollection, descriptor: RoutineDescriptor, args: UpdateArgs, result: Map<string, ExecuteResult>) {
-        const preResult = result.get(previous)
-        const conditionResult = result.get(condition)
-        if (preResult !== conditionResult?.condition.value) return
-
-        this.doExecute(condition, previous, customInputs, descriptor, args, result)
-    }
-
-    async doExecute(execute: string, previous: string, customInputs: InteractionInputCollection, descriptor: RoutineDescriptor, args: UpdateArgs, result: Map<string, ExecuteResult>) {
-        const nexts = this.linkCollection.get(execute)
-        if (nexts === undefined) return
-
-        for (const next of nexts) {
-            await this.doNext(next, execute, customInputs, descriptor, args, result)
-        }
-    }
-
-    async doNext(current: string, previous: string, customInputs: InteractionInputCollection, descriptor: RoutineDescriptor, args: UpdateArgs, result: Map<string, ExecuteResult>) {
-        const active = this.collection.get(current)
-        if (active === undefined) return
-
-        const currentInput = customInputs[current] ?? {}
-        const script = Asset.get<Scriptable>(active.url)
-        if (script) {
-            const event = { ...args, input: { previous, default: active.input, user: currentInput }, result }
-            const executeResult = await script.execute(descriptor, this.graphics, event)
-            result.set(current, executeResult)
-        }
-
-        if (active.routine === 'Branch') {
-            this.doBranch(current, previous, customInputs, descriptor, args, result)
-        } else if (active.routine === 'Condition') {
-            if (result.has(current) === false) result.set(current, active.input)
-            this.doCondition(current, previous, customInputs, descriptor, args, result)
-        } else {
-            this.doExecute(current, previous, customInputs, descriptor, args, result)
-        }
-    }
-
-    do(customInputs: InteractionInputCollection, descriptor: RoutineDescriptor, args: UpdateArgs) {
-        for (const root of descriptor.roots) {
-            const resultCollection = new Map()
-            this.doNext(root, '', customInputs, descriptor, args, resultCollection)
-        }
-    }
-
-}
-Interpreter.register(RoutineInterpreter)
-
-export {
-    RoutineInterpreter
-}

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

@@ -1,27 +0,0 @@
-import { Asset } from "../../../asset";
-import { RoutineDescriptor } from "../../../descriptor";
-import { graphics } from "../../execute"
-
-const url = Asset.createVirtualUrl('preset/graphics/invoke.routine.json')
-const nodes = {
-    invoke: 'invoke'
-}
-let _currentRoutine: RoutineDescriptor | null = null
-const routineProvider = async () => {
-    if (_currentRoutine === null) {
-        _currentRoutine = new RoutineDescriptor()
-        const invokeNode = graphics.invoke.createExecuteNode({ id: nodes.invoke })
-        _currentRoutine.nodes.push(invokeNode)
-        _currentRoutine.roots.push(invokeNode.id)
-    }
-    return _currentRoutine
-}
-
-Asset.provider(url, routineProvider)
-
-export {
-    url,
-    nodes,
-}
-
-

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

@@ -1,27 +0,0 @@
-import { Asset } from "../../../asset";
-import { RoutineDescriptor } from "../../../descriptor";
-import { scheduler } from "../../execute"
-
-const url = Asset.createVirtualUrl('preset/scheduler/switch.routine.json')
-const nodes = {
-    switch: 'switch',
-}
-let _currentRoutine: RoutineDescriptor | null = null
-const routineProvider = async () => {
-    if (_currentRoutine === null) {
-        _currentRoutine = new RoutineDescriptor()
-        const switchNode = scheduler.switch.createExecuteNode({ id: nodes.switch })
-        _currentRoutine.nodes.push(switchNode)
-        _currentRoutine.roots.push(switchNode.id)
-    }
-    return _currentRoutine
-}
-
-Asset.provider(url, routineProvider)
-
-export {
-    url,
-    nodes,
-}
-
-