@vyr/engine 0.0.1 → 0.0.2

package/src/graphics/Compilation.ts

@@ -1,7 +1,7 @@
 import { Engine } from "../Engine";
-import { Graphics } from "./Graphics";
+import { Graphics, TickArgs } from "./Graphics";
 import { Asset } from "../asset";
-import { AnimationUnitDescriptor, ServiceSchedulerDescriptor, UpdateArgs } from "../descriptor";
+import { AnimationUnitDescriptor, ServiceSchedulerDescriptor } from "../descriptor";
 
 class Compilation {
     private collection = new Map<string, Graphics>()
@@ -18,7 +18,7 @@ class Compilation {
                 graphics = new Graphics(url, scheduler, engine)
                 this.collection.set(scheduler.uuid, graphics)
             }
-            graphics.listen({ delta: 0 })
+            graphics.listen()
 
             return graphics
         }
@@ -27,46 +27,35 @@ class Compilation {
     unlisten(scheduler: ServiceSchedulerDescriptor, engine: Engine) {
         const graphics = this.collection.get(scheduler.uuid)
         if (graphics === undefined) return
-        graphics.unlisten({ delta: 0 })
+        graphics.unlisten()
         this.collection.delete(scheduler.uuid)
     }
 
-    process(engine: Engine, args: UpdateArgs) {
-        Asset.free()
-
+    foreach(executor: (graphics: Graphics) => void) {
         const collection = this.collection.values()
 
         for (const graphics of collection) {
+            executor(graphics)
+        }
+    }
 
-            graphics.process(args)
-
-            graphics.clear(args)
-
-            engine.trigger(AnimationUnitDescriptor.type, args)
+    process(engine: Engine, args: TickArgs) {
+        Asset.free()
 
-            this.beforeRender(args)
-            engine.trigger('beforeRender', args)
+        this.foreach((graphics) => {
+            graphics.process()
+            graphics.clear()
+        })
 
-            this.render(args)
+        engine.trigger(AnimationUnitDescriptor.type, args)
 
-            this.afterRender(args)
-            engine.trigger('afterRender', args)
-        }
-    }
+        this.foreach((graphics) => graphics.beforeRender())
 
-    beforeRender(args: UpdateArgs) {
-        const collection = this.collection.values()
-        for (const graphics of collection) graphics.beforeRender(args)
-    }
+        engine.trigger('beforeRender', args)
 
-    render(args: UpdateArgs) {
-        const collection = this.collection.values()
-        for (const graphics of collection) graphics.render(args)
-    }
+        this.foreach((graphics) => graphics.render())
 
-    afterRender(args: UpdateArgs) {
-        const collection = this.collection.values()
-        for (const graphics of collection) graphics.afterRender(args)
+        engine.trigger('afterRender', args)
     }
 
     clear(engine: Engine) {

package/src/graphics/Graphics.ts

@@ -1,15 +1,20 @@
 import { language } from '../locale'
 import { ArrayUtils } from "../ArrayUtils";
 import { Asset, Dependencide } from "../asset";
-import { Descriptor, HTMLDescriptor, HTMLServiceDescriptor, RoutineDescriptor, ServiceDescriptor, ServiceSchedulerDescriptor, UpdateArgs } from "../descriptor";
+import { DatasetDescriptor, Descriptor, HTMLDescriptor, HTMLServiceDescriptor, ServiceDescriptor, ServiceSchedulerDescriptor } from "../descriptor";
 import { privateState } from "../interpreter/Interpreter";
-import { Interpreter, RoutineInterpreter, ServiceInterpreter, ServiceSchedulerInterpreter } from "../interpreter";
+import { Interpreter, ServiceInterpreter, ServiceSchedulerInterpreter } from "../interpreter";
 import { observer, UpdateDepsWatcherArgs, UpdateWatcherArgs, WatcherArgs } from "./Observer";
 import { Operation, Queue, Unit } from "./Unit";
 import { Actor } from '../actor/Actor';
 import { UnitCollection } from "./Collection";
 import { VariableProxy } from "./VariableProxy";
 import { Engine } from '../Engine';
+import { InteractionDescriptor } from '../interaction';
+
+interface TickArgs {
+    delta: number
+}
 
 interface PickupObject {
     [k: string]: any
@@ -17,7 +22,7 @@ interface PickupObject {
     generatedBy: string
 }
 
-type OverrideUpdate = (descriptor: Descriptor, interpreter: Interpreter, args: UpdateArgs) => void
+type OverrideUpdate = (descriptor: Descriptor, interpreter: Interpreter) => void
 
 class Graphics {
     static createInterpreter<T extends Interpreter = Interpreter>(descriptor: Descriptor, graphics: Graphics) {
@@ -41,6 +46,13 @@ class Graphics {
     private readonly _services: ServiceDescriptor[] = []
     private readonly _freeQueue: Unit[] = []
     private _currentCamera = ''
+    private _currentArgs: TickArgs = { delta: 0 }
+    get args() {
+        return this._currentArgs
+    }
+    set args(args: TickArgs) {
+        this._currentArgs = args
+    }
     readonly unitCollection = new UnitCollection()
     readonly variableProxy = new VariableProxy()
     readonly scheduler: ServiceSchedulerDescriptor
@@ -53,7 +65,7 @@ class Graphics {
         this.url = url
     }
 
-    listen(args: UpdateArgs) {
+    listen() {
         observer.listen('add', this.addWatcher)
         observer.listen('remove', this.removeWatcher)
         observer.listen('update', this.updateWatcher)
@@ -64,22 +76,22 @@ class Graphics {
         if (root instanceof Descriptor) this.addRoot(this.url, root)
 
         Asset.graph.getDependencide(this.url, this._dependencide)
-        this._dependencide.foreach(asset => {
+        this._dependencide.forEachForGraphics(asset => {
             const root = Asset.get<Descriptor>(asset)
             if (root instanceof Descriptor) {
                 this._assetCollection.set(asset, this.addRoot(asset, root))
             }
         })
 
-        const descriptor = this.variableProxy.get<ServiceSchedulerDescriptor>(this.scheduler.uuid, this, args)
+        const descriptor = this.variableProxy.get<ServiceSchedulerDescriptor>(this.scheduler.uuid, this)
         const interpreter = this.getInterpreter<ServiceSchedulerInterpreter>(descriptor)
-        interpreter.install(descriptor, args)
+        interpreter.install(descriptor)
     }
 
-    unlisten(args: UpdateArgs) {
-        const descriptor = this.variableProxy.get<ServiceSchedulerDescriptor>(this.scheduler.uuid, this, args)
+    unlisten() {
+        const descriptor = this.variableProxy.get<ServiceSchedulerDescriptor>(this.scheduler.uuid, this)
         const interpreter = this.getInterpreter<ServiceSchedulerInterpreter>(descriptor)
-        interpreter.uninstall(descriptor, args)
+        interpreter.uninstall(descriptor)
 
         const master = this.unitCollection.get(this.scheduler.uuid) as Unit
         const assets = [...this._assetCollection.values(), master]
@@ -87,12 +99,12 @@ class Graphics {
         for (const asset of assets) {
             const unit = this.removeRoot(asset.queue.url)
             if (unit === null) continue
-            unit.queue.iterator(operation => this.do(operation, args))
+            unit.queue.iterator(operation => this.do(operation))
             this._assetCollection.delete(asset.queue.url)
         }
 
         const _freeQueue = this._freeCollection.values()
-        for (const unit of _freeQueue) this.doFree(unit, args)
+        for (const unit of _freeQueue) this.doFree(unit)
 
         observer.unlisten('add', this.addWatcher)
         observer.unlisten('remove', this.removeWatcher)
@@ -103,11 +115,11 @@ class Graphics {
         this._dependencide.clear()
     }
 
-    process(args: UpdateArgs) {
-        for (const unit of this._freeQueue) this.doFree(unit, args)
+    process() {
+        for (const unit of this._freeQueue) this.doFree(unit)
         this._freeQueue.length = 0
 
-        this.updateStaticAsset(args)
+        this.updateStaticAsset()
 
         this._dependencide.clear()
         Asset.graph.getDependencide(this.url, this._dependencide)
@@ -116,7 +128,7 @@ class Graphics {
 
         for (const removeAsset of patch.removeQueue) {
             const unit = this.removeRoot(removeAsset)
-            if (unit !== null) unit.queue.iterator(operation => this.do(operation, args))
+            if (unit !== null) unit.queue.iterator(operation => this.do(operation))
             this._assetCollection.delete(removeAsset)
         }
         for (const addAsset of patch.addQueue) {
@@ -127,7 +139,7 @@ class Graphics {
         }
 
         const assets: Unit[] = []
-        this._dependencide.foreach(asset => {
+        this._dependencide.forEachForGraphics(asset => {
             const descriptor = Asset.get<Descriptor>(asset)
             const unit = this.unitCollection.get(descriptor.uuid)
             if (unit === undefined) return console.warn(asset, descriptor)
@@ -136,18 +148,18 @@ class Graphics {
         assets.push(...this._staticAssetQueue)
 
         for (const asset of assets) {
-            asset.queue.iterator(operation => this.do(operation, args))
+            asset.queue.iterator(operation => this.do(operation))
         }
 
         const master = this.unitCollection.get(this.scheduler.uuid) as Unit
 
-        master.queue.iterator(operation => this.do(operation, args))
+        master.queue.iterator(operation => this.do(operation))
 
         for (const asset of assets) {
-            asset.queue.iterator(unit => this.doUpdate(unit, args), Queue.Update)
+            asset.queue.iterator(unit => this.doUpdate(unit), Queue.Update)
         }
 
-        const invokeQueue = master.queue.iterator(unit => this.doUpdate(unit, args), Queue.Update)
+        const invokeQueue = master.queue.iterator(unit => this.doUpdate(unit), Queue.Update)
         for (const unit of invokeQueue) {
             const descriptor = Descriptor.get<Descriptor>(unit.uuid)
             this.invoke('mount', descriptor)
@@ -157,35 +169,35 @@ class Graphics {
         this._freeCollection.clear()
     }
 
-    clear(args: UpdateArgs) {
+    clear() {
         for (const service of this._services) {
-            const descriptor = this.variableProxy.get<ServiceDescriptor>(service.uuid, this, args)
+            const descriptor = this.variableProxy.get<ServiceDescriptor>(service.uuid, this)
             const interpreter = this.getInterpreter<ServiceInterpreter>(descriptor)
-            interpreter.clear(descriptor, args)
+            interpreter.clear(descriptor)
         }
     }
 
-    beforeRender(args: UpdateArgs) {
+    beforeRender() {
         for (const service of this._services) {
-            const descriptor = this.variableProxy.get<ServiceDescriptor>(service.uuid, this, args)
+            const descriptor = this.variableProxy.get<ServiceDescriptor>(service.uuid, this)
             const interpreter = this.getInterpreter<ServiceInterpreter>(descriptor)
-            interpreter.beforeRender(descriptor, args)
+            interpreter.beforeRender(descriptor)
         }
     }
 
-    render(args: UpdateArgs) {
+    render() {
         for (const service of this._services) {
-            const descriptor = this.variableProxy.get<ServiceDescriptor>(service.uuid, this, args)
+            const descriptor = this.variableProxy.get<ServiceDescriptor>(service.uuid, this)
             const interpreter = this.getInterpreter<ServiceInterpreter>(descriptor)
-            interpreter.render(descriptor, args)
+            interpreter.render(descriptor)
         }
     }
 
-    afterRender(args: UpdateArgs) {
+    afterRender() {
         for (const service of this._services) {
-            const descriptor = this.variableProxy.get<ServiceDescriptor>(service.uuid, this, args)
+            const descriptor = this.variableProxy.get<ServiceDescriptor>(service.uuid, this)
             const interpreter = this.getInterpreter<ServiceInterpreter>(descriptor)
-            interpreter.afterRender(descriptor, args)
+            interpreter.afterRender(descriptor)
         }
     }
 
@@ -194,6 +206,8 @@ 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 })
@@ -281,7 +295,7 @@ class Graphics {
         })
     }
 
-    private updateStaticAsset(args: UpdateArgs) {
+    private updateStaticAsset() {
         if (this.scheduler.camera !== this._currentCamera) {
             const descriptor = Descriptor.get<Descriptor>(this.scheduler.camera)
             if (descriptor === null) return
@@ -302,7 +316,7 @@ class Graphics {
         const temp = new Map(this._assetCollection)
         const addQueue: string[] = [], removeQueue: string[] = []
 
-        this._dependencide.foreach(asset => {
+        this._dependencide.forEachForGraphics(asset => {
             temp.has(asset) ? temp.delete(asset) : addQueue.push(asset)
         })
         removeQueue.push(...temp.keys())
@@ -310,41 +324,41 @@ class Graphics {
         return { addQueue, removeQueue }
     }
 
-    private onMount(unit: Unit, args: UpdateArgs) {
-        const parentDescriptor = this.variableProxy.get<Descriptor>(unit.parent, this, args)
+    private onMount(unit: Unit) {
+        const parentDescriptor = this.variableProxy.get<Descriptor>(unit.parent, this)
         const parentInterpreter = this.getInterpreter(parentDescriptor)
 
-        const descriptor = this.variableProxy.get<Descriptor>(unit.uuid, this, args)
+        const descriptor = this.variableProxy.get<Descriptor>(unit.uuid, this)
         const interpreter = this.getInterpreter(descriptor)
 
         if (descriptor instanceof ServiceDescriptor) ArrayUtils.insert(this._services, descriptor)
 
-        interpreter.mount(descriptor, args, parentInterpreter, parentDescriptor)
+        interpreter.mount(descriptor, parentInterpreter, parentDescriptor)
     }
 
-    private onUnmount(unit: Unit, args: UpdateArgs) {
-        const parentDescriptor = this.variableProxy.get<Descriptor>(unit.parent, this, args)
+    private onUnmount(unit: Unit) {
+        const parentDescriptor = this.variableProxy.get<Descriptor>(unit.parent, this)
         const parentInterpreter = this.getInterpreter(parentDescriptor)
 
-        const descriptor = this.variableProxy.get<Descriptor>(unit.uuid, this, args)
+        const descriptor = this.variableProxy.get<Descriptor>(unit.uuid, this)
         const interpreter = this.getInterpreter(descriptor)
 
         if (descriptor instanceof ServiceDescriptor) ArrayUtils.remove(this._services, descriptor)
 
-        interpreter.unmount(descriptor, args, parentInterpreter, parentDescriptor)
+        interpreter.unmount(descriptor, parentInterpreter, parentDescriptor)
     }
 
     getUnit<T extends Unit | null = Unit>(uuid: string) {
         return (this.unitCollection.get(uuid) ?? null) as T
     }
 
-    do(operation: Operation, args: UpdateArgs) {
+    do(operation: Operation) {
         switch (operation.type) {
             case Queue.Add:
-                this.onMount(operation.unit, args)
+                this.onMount(operation.unit)
                 break;
             case Queue.Remove:
-                this.onUnmount(operation.unit, args)
+                this.onUnmount(operation.unit)
                 break;
             default:
                 console.log('do', operation.type)
@@ -352,18 +366,18 @@ class Graphics {
         }
     }
 
-    doUpdate(unit: Unit, args: UpdateArgs) {
-        const descriptor = this.variableProxy.get<Descriptor>(unit.uuid, this, args)
+    doUpdate(unit: Unit) {
+        const descriptor = this.variableProxy.get<Descriptor>(unit.uuid, this)
         const interpreter = this.getInterpreter(descriptor)
         const override = this._overwriteUpdate.get(descriptor.uuid)
-        override === undefined ? interpreter.update(descriptor, args) : override(descriptor, interpreter, args)
+        override === undefined ? interpreter.update(descriptor) : override(descriptor, interpreter)
     }
 
-    doFree(unit: Unit, args: UpdateArgs) {
+    doFree(unit: Unit) {
         const interpreter = this._interpreterCollection.get(unit.uuid)
         if (interpreter === undefined) return
-        const descriptor = this.variableProxy.get<Descriptor>(unit.uuid, this, args)
-        interpreter.free(descriptor, args)
+        const descriptor = this.variableProxy.get<Descriptor>(unit.uuid, this)
+        interpreter.free(descriptor)
         this._interpreterCollection.delete(unit.uuid)
     }
 
@@ -382,18 +396,18 @@ class Graphics {
         return Descriptor.get<T>(unit.parent)
     }
 
-    getActor<T extends Actor = Actor>(descriptor: Descriptor, args: UpdateArgs) {
+    getActor<T extends Actor = Actor>(descriptor: Descriptor) {
         const interpreter = this.getInterpreter(descriptor)
-        return interpreter.getActor<T>(descriptor, args)
+        return interpreter.getActor<T>(descriptor)
     }
 
-    private _pickupItem(target: Descriptor, args: UpdateArgs, result: PickupObject[]) {
+    private _pickupItem(target: Descriptor, result: PickupObject[]) {
         if (target.selectable === false) return
         const interpreter = this._interpreterCollection.get(target.uuid)
         if (interpreter === undefined) return
-        interpreter.pickup(target, args, result)
+        interpreter.pickup(target, result)
     }
-    private _pickupScene(args: UpdateArgs, result: PickupObject[]) {
+    private _pickupScene(result: PickupObject[]) {
         const master = this.unitCollection.get(this.scheduler.uuid)
         if (master === undefined) return result
 
@@ -401,7 +415,7 @@ class Graphics {
         for (const unit of units) {
             const descriptor = Descriptor.get<Descriptor>(unit.uuid)
             if (descriptor instanceof HTMLDescriptor) continue
-            this._pickupItem(descriptor, args, result)
+            this._pickupItem(descriptor, result)
         }
     }
 
@@ -434,15 +448,15 @@ class Graphics {
         const args = { delta: 0 }
         if (target instanceof ServiceDescriptor) {
             if (target instanceof HTMLServiceDescriptor) {
-                this._pickupItem(target, args, result)
+                this._pickupItem(target, result)
             } else {
                 const interpreter = this.getInterpreter<ServiceInterpreter>(target)
-                interpreter.beforePickup(mouse, rect, args)
-                this._pickupScene(args, result)
+                interpreter.beforePickup(mouse, rect)
+                this._pickupScene(result)
                 interpreter.orderBy(result)
             }
         } else {
-            this._pickupItem(target, args, result)
+            this._pickupItem(target, result)
         }
 
         return result
@@ -450,12 +464,10 @@ class Graphics {
 
     invoke(interaction: string, descriptor: Descriptor) {
         if (descriptor.interactions.length === 0) return
-        const eventArgs = { delta: 0, trigger: descriptor }
         for (const inter of descriptor.interactions) {
             if (inter.type === interaction) {
-                const routine = Asset.get<RoutineDescriptor>(inter.url)
-                const interpreter = this.getInterpreter<RoutineInterpreter>(routine)
-                interpreter.do(inter.inputs, routine, eventArgs)
+                const current = Asset.get<InteractionDescriptor>(inter.url)
+                if (current !== null) current.execute(inter.inputs, this, descriptor)
                 break
             }
         }
@@ -471,5 +483,6 @@ class Graphics {
 
 export {
     PickupObject,
+    TickArgs,
     Graphics,
 }

package/src/graphics/VariableProxy.ts

@@ -1,7 +1,7 @@
 import { ObjectUtils } from "../ObjectUtils";
 import { Asset } from "../asset";
-import { Scriptable } from "../Scriptable";
-import { Data, DatasetDescriptor, Descriptor, UpdateArgs, VariabConfig } from "../descriptor";
+import { Scriptable, ScriptableArgs } from "../interaction/Scriptable";
+import { Data, DatasetDescriptor, Descriptor, VariabConfig } from "../descriptor";
 import { Graphics } from "./Graphics";
 
 interface ActorCollection { [k: string]: any }
@@ -34,18 +34,18 @@ class VariableProxy {
             }
         });
     }
-    private getVariableValue = (descriptor: Descriptor, data: Data, key: string, config: VariabConfig, graphics: Graphics, args: UpdateArgs) => {
+    private getVariableValue = (descriptor: Descriptor, data: Data, key: string, config: VariabConfig, graphics: Graphics) => {
         if (config.type === 'key') {
             return ObjectUtils.getValueByKey(data, config.value)
         } else if (config.type === 'custom') {
-            const scriptable = Asset.get<Scriptable>(config.value)
+            const scriptable = Asset.get<Scriptable<ScriptableArgs<undefined, undefined, undefined>>>(config.value)
             if (scriptable === null) return
-            const currentArgs = { ...args, key, config, data }
-            return scriptable.execute(descriptor, graphics, currentArgs)
+            const currentArgs = { key, config, data, input: undefined, result: undefined, trigger: descriptor }
+            return scriptable.execute(graphics, currentArgs)
         }
     }
 
-    get<T extends Descriptor | null = Descriptor | null>(uuid: string, graphics: Graphics, args: UpdateArgs) {
+    get<T extends Descriptor | null = Descriptor | null>(uuid: string, graphics: Graphics) {
         const descriptor = Descriptor.get<Descriptor>(uuid)
         if (descriptor === null) return null as unknown as T
 
@@ -63,7 +63,7 @@ class VariableProxy {
                 for (const key of keys) {
                     const variable = descriptor.variables[key]
                     if (variable.enabled === false) continue
-                    const value = this.getVariableValue(descriptor, data, key, variable, graphics, args)
+                    const value = this.getVariableValue(descriptor, data, key, variable, graphics)
                     if (value === undefined) continue
                     variables[key] = value
                 }

package/src/index.ts

@@ -15,7 +15,8 @@ export { Listener } from './Listener'
 export { InputSystem } from './InputSystem'
 export { destroyInstance } from './ObjectPool'
 export * from './AsyncTask'
-export * from './Scriptable'
+export * from './interaction/Scriptable'
+export * from './interaction'
 export * from './descriptor'
 export * from './interpreter'
 export * from './utils'

package/src/interaction/InteractionDescriptor.ts

@@ -0,0 +1,96 @@
+import { DeserializationObject, Serialization } from "../Serialization";
+import { Descriptor } from "../descriptor";
+import { AssetProperty, AssetPropertyCollection } from "../asset";
+import { Graphics } from "../graphics";
+import { InteractionExecutor } from "./InteractionExecutor";
+
+interface InteractionInput {
+    [param: string]: {
+        type?: 'data' | string
+        value: any
+    }
+}
+
+interface InteractionInputCollection {
+    [id: string]: InteractionInput
+}
+
+interface InteractionProperty extends AssetProperty {
+    uuid: string
+    type: string
+    inputs: InteractionInputCollection
+}
+
+interface InteractionPropertyCollection extends AssetPropertyCollection<InteractionProperty> { }
+
+interface InteractionNode {
+    id: string
+    label: string
+    position: { x: number; y: number }
+    interaction: string
+    url: string
+    input: InteractionInput
+}
+
+interface InteractionMapper {
+    source: string
+    target: string
+}
+
+const privateState = {
+    executorPool: new WeakMap<Descriptor, InteractionExecutor>()
+}
+
+class InteractionDescriptor extends Descriptor {
+    static type = 'Interaction'
+    roots: string[]
+    nodes: InteractionNode[]
+    mappers: InteractionMapper[]
+
+    constructor(descriptor: Partial<DeserializationObject<InteractionDescriptor>> = {}) {
+        super(descriptor)
+        this.roots = descriptor.roots ? Serialization.deepClone(descriptor.roots) : []
+        this.nodes = descriptor.nodes ? Serialization.deepClone(descriptor.nodes) : []
+        this.mappers = descriptor.mappers ? Serialization.deepClone(descriptor.mappers) : []
+    }
+
+    addNode(nodes: InteractionNode[]) {
+        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 })
+            }
+        }
+    }
+
+    async execute(customInputs: InteractionInputCollection, graphics: Graphics, trigger: Descriptor, otherArgs?: { [k: string]: any }) {
+        let executor = privateState.executorPool.get(this)
+        if (executor === undefined) {
+            executor = new InteractionExecutor()
+            executor.update(this)
+            privateState.executorPool.set(this, executor)
+        }
+        await executor.execute(customInputs, this, graphics, trigger,otherArgs)
+    }
+
+    setNeedsUpdate() {
+        const executor = privateState.executorPool.get(this)
+        if (executor === undefined) return
+        executor.update(this)
+    }
+}
+
+Descriptor.register(InteractionDescriptor)
+
+export {
+    InteractionInput,
+    InteractionInputCollection,
+    InteractionProperty,
+    InteractionPropertyCollection,
+    InteractionNode,
+    InteractionMapper,
+    InteractionDescriptor,
+}