@vyr/engine 0.0.2 → 0.0.3

package/package.json

@@ -1 +1 @@
-{"name":"@vyr/engine","version":"0.0.2","description":"","main":"./src/index.ts","author":"","license":"MIT","dependencies":{"@vyr/locale":"0.0.2","tinycolor2":"1.6.0"},"devDependencies":{"@types/tinycolor2":"1.4.6"},"files":["package.json","src/"]}
+{"name":"@vyr/engine","version":"0.0.3","description":"","main":"./src/index.ts","author":"","license":"MIT","dependencies":{"@vyr/locale":"0.0.3","tinycolor2":"1.6.0"},"devDependencies":{"@types/tinycolor2":"1.4.6"},"files":["package.json","src/"]}

package/src/Engine.ts

@@ -1,4 +1,5 @@
 import { language } from './locale'
+import { Asset } from './asset'
 import { ServiceSchedulerDescriptor, StyleDescriptor } from './descriptor'
 import { Generate } from './Generate'
 import { InputSystem } from './InputSystem'
@@ -15,6 +16,7 @@ interface EngineListener {
 
 class Engine extends Listener<EngineListener> {
   private compilation = new Compilation()
+  private active = ''
   private prevTimestamp = 0
   private frame = 0
 
@@ -76,9 +78,17 @@ class Engine extends Listener<EngineListener> {
   }
 
   switch(scheduler: ServiceSchedulerDescriptor) {
-    this.compilation.clear(this)
+    const url = Asset.getUrlByUuid(scheduler.uuid)
 
-    this.compilation.listen(scheduler, this)
+    if (!url) throw '切换失败，无法获资产地址！'
+
+    const current = Asset.get<ServiceSchedulerDescriptor>(this.active)
+    if (current) this.compilation.unlisten(current)
+
+    const graphics = this.compilation.ensureExists(url, scheduler, this)
+
+    this.compilation.listen(graphics)
+    this.active = url
 
     window.dispatchEvent(new Event('resize'))
 
@@ -90,12 +100,16 @@ class Engine extends Listener<EngineListener> {
   }
 
   clear() {
-    this.compilation.clear(this)
+    this.compilation.clear()
   }
 
   getGraphics(scheduler: ServiceSchedulerDescriptor) {
     return this.compilation.get(scheduler)
   }
+
+  ensureGraphicsExists(url: string, scheduler: ServiceSchedulerDescriptor) {
+    return this.compilation.ensureExists(url, scheduler, this)
+  }
 }
 
 export { Engine }

package/src/asset/Asset.ts

@@ -1,9 +1,10 @@
 import { language } from "../locale"
 import { Category } from "../Category"
 import { AsyncTask } from "../AsyncTask"
-import { DatasetDescriptor, Descriptor } from "../descriptor"
+import { DatasetDescriptor, Descriptor, ServiceSchedulerDescriptor } from "../descriptor"
 import { InteractionDescriptor, Scriptable, ScriptableArgs } from "../interaction"
 import { AssetGraph } from "./AssetGraph"
+import { Engine } from "../Engine"
 
 type JsonAsset = { [k: string]: any }
 type RawAsset = HTMLImageElement | ImageBitmap | HTMLAudioElement | AudioBuffer | HTMLVideoElement | string | JsonAsset
@@ -31,7 +32,7 @@ const privateState = {
 }
 
 class Asset {
-    static baseUrl = ''
+    static baseUrl = location.origin
     static graph = new AssetGraph()
 
     static fetch(url: string, params?: any) {
@@ -169,6 +170,20 @@ class Asset {
         privateState.activeAssets.length = 0
     }
 
+    static async compileDataset(url: string, engine: Engine) {
+        const descriptor = this.get<ServiceSchedulerDescriptor>(url)
+        const graphics = engine.ensureGraphicsExists(url, descriptor)
+        const dependencide = Asset.graph.getDependencide(url)
+
+        const queue: Promise<void>[] = []
+        for (const dataset of dependencide.dataset) {
+            const trigger = Asset.get<Descriptor>(dataset)
+            queue.push(graphics.invoke('compile', trigger))
+        }
+
+        await Promise.all(queue)
+    }
+
     static async loadAll(url: string, forced = false, record: string[] = []) {
         await Asset.load(url, forced)
         Asset.graph.create(url)
@@ -214,7 +229,7 @@ Asset.register(Category.scene, factoryDescriptor)
 const factoryDataset = async (url: string) => {
     const asset = await factoryDescriptor(url) as DatasetDescriptor
     // if (asset.auto) await asset.fetch()
-    
+
     return asset
 }
 Asset.register(Category.dataset, factoryDataset)

package/src/graphics/Compilation.ts

@@ -10,27 +10,30 @@ class Compilation {
         return (this.collection.get(scheduler.uuid) ?? null) as Graphics
     }
 
-    listen(scheduler: ServiceSchedulerDescriptor, engine: Engine) {
-        const url = Asset.getUrlByUuid(scheduler.uuid)
-        if (url) {
-            let graphics = this.collection.get(scheduler.uuid)
-            if (graphics === undefined) {
-                graphics = new Graphics(url, scheduler, engine)
-                this.collection.set(scheduler.uuid, graphics)
-            }
-            graphics.listen()
-
-            return graphics
-        }
-    }
-
-    unlisten(scheduler: ServiceSchedulerDescriptor, engine: Engine) {
+    delete(scheduler: ServiceSchedulerDescriptor) {
         const graphics = this.collection.get(scheduler.uuid)
         if (graphics === undefined) return
         graphics.unlisten()
         this.collection.delete(scheduler.uuid)
     }
 
+    ensureExists(url: string, scheduler: ServiceSchedulerDescriptor, engine: Engine) {
+        let graphics = this.collection.get(scheduler.uuid)
+        if (graphics === undefined) {
+            graphics = new Graphics(url, scheduler, engine)
+            this.collection.set(scheduler.uuid, graphics)
+        }
+        return graphics
+    }
+
+    listen(graphics: Graphics) {
+        graphics.listen()
+    }
+
+    unlisten(scheduler: ServiceSchedulerDescriptor) {
+        this.delete(scheduler)
+    }
+
     foreach(executor: (graphics: Graphics) => void) {
         const collection = this.collection.values()
 
@@ -58,10 +61,10 @@ class Compilation {
         engine.trigger('afterRender', args)
     }
 
-    clear(engine: Engine) {
+    clear() {
         const collection = this.collection.values()
         for (const graphics of collection) {
-            this.unlisten(graphics.scheduler, engine)
+            this.unlisten(graphics.scheduler)
         }
     }
 }

package/src/graphics/Graphics.ts

@@ -151,7 +151,8 @@ class Graphics {
             asset.queue.iterator(operation => this.do(operation))
         }
 
-        const master = this.unitCollection.get(this.scheduler.uuid) as Unit
+        const master = this.unitCollection.get(this.scheduler.uuid)
+        if (master === undefined) return
 
         master.queue.iterator(operation => this.do(operation))
 
@@ -206,8 +207,6 @@ class Graphics {
         this.unitCollection.set(unit)
         this._freeCollection.delete(unit.uuid)
 
-        if (root instanceof DatasetDescriptor) this.invoke('compile', root)
-
         unit.trigger(Queue.Update)
         for (const sub of root.children) {
             observer.trigger('add', { self: sub.uuid, puid: root.uuid })
@@ -462,12 +461,12 @@ class Graphics {
         return result
     }
 
-    invoke(interaction: string, descriptor: Descriptor) {
+    async invoke(interaction: string, descriptor: Descriptor) {
         if (descriptor.interactions.length === 0) return
         for (const inter of descriptor.interactions) {
             if (inter.type === interaction) {
                 const current = Asset.get<InteractionDescriptor>(inter.url)
-                if (current !== null) current.execute(inter.inputs, this, descriptor)
+                if (current !== null) await current.execute(inter.inputs, this, descriptor)
                 break
             }
         }

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

@@ -1,22 +1,78 @@
 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 { input, result } = args
-        console.log(args)
+        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)
 
-        return {}
+                    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

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

@@ -8,7 +8,7 @@ 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]) => {
@@ -87,6 +87,7 @@ const createExecuteNode = (options: { id: string; position?: any; input?: any })
 
 export {
     scriptable,
+    ExecuteScriptable,
     createExecuteInput,
     createExecuteNode,
 }

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

@@ -10,6 +10,7 @@ class ExecuteScriptable extends Scriptable {
         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)
     }

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

@@ -11,7 +11,7 @@ const interactionProvider = async () => {
     if (_currentInteraction === null) {
         _currentInteraction = new InteractionDescriptor()
         const invokeNode = graphics.invoke.createExecuteNode({ id: nodes.invoke })
-        _currentInteraction.nodes.push(invokeNode)
+        _currentInteraction.addNode([invokeNode])
         _currentInteraction.roots.push(invokeNode.id)
     }
     return _currentInteraction

package/src/preset/interaction/index.ts

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

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

@@ -11,7 +11,7 @@ const interactionProvider = async () => {
     if (_currentInteraction === null) {
         _currentInteraction = new InteractionDescriptor()
         const switchNode = scheduler.switch.createExecuteNode({ id: nodes.switch })
-        _currentInteraction.nodes.push(switchNode)
+        _currentInteraction.addNode([switchNode])
         _currentInteraction.roots.push(switchNode.id)
     }
     return _currentInteraction