@vyr/cli 0.0.12 → 0.0.13

package/output/engine/src/graphics/Graphics.ts

@@ -0,0 +1,487 @@
+import { language } from '../locale'
+import { ArrayUtils } from "../ArrayUtils";
+import { Asset, Dependencide } from "../asset";
+import { DatasetDescriptor, Descriptor, HTMLDescriptor, HTMLServiceDescriptor, ServiceDescriptor, ServiceSchedulerDescriptor } from "../descriptor";
+import { privateState } from "../interpreter/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
+    uuid: string
+    generatedBy: string
+}
+
+type OverrideUpdate = (descriptor: Descriptor, interpreter: Interpreter) => void
+
+class Graphics {
+    static createInterpreter<T extends Interpreter = Interpreter>(descriptor: Descriptor, graphics: Graphics) {
+        const Class = Interpreter.getClass(descriptor.type)
+        if (Class === null) throw language.get('graphics.interpreter.notRegister', { type: descriptor.type })
+        privateState.factory = true
+        let unit = graphics.unitCollection.get(descriptor.uuid) as Unit
+        if (unit === undefined) unit = graphics._freeCollection.get(descriptor.uuid) as Unit
+        const interpreter = new Class(unit, graphics) as T
+        privateState.factory = false
+        return interpreter
+    }
+
+    __VYR_REMOTE_WRAPPER?: boolean
+    private readonly _overwriteUpdate = new Map<string, OverrideUpdate>()
+    private readonly _interpreterCollection = new Map<string, Interpreter>()
+    private readonly _staticAssetQueue: Unit[] = []
+    private readonly _assetCollection = new Map<string, Unit>()
+    private readonly _freeCollection = new Map<string, Unit>()
+    private readonly _dependencide = new Dependencide()
+    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
+    readonly engine: Engine
+    readonly url: string
+
+    constructor(url: string, scheduler: ServiceSchedulerDescriptor, engine: Engine) {
+        this.scheduler = scheduler
+        this.engine = engine
+        this.url = url
+    }
+
+    listen() {
+        observer.listen('add', this.addWatcher)
+        observer.listen('remove', this.removeWatcher)
+        observer.listen('update', this.updateWatcher)
+        observer.listen('updateDeps', this.updateDepsWatcher)
+        observer.listen('free', this.freeWatcher)
+
+        const root = Asset.get<Descriptor>(this.url)
+        if (root instanceof Descriptor) this.addRoot(this.url, root)
+
+        Asset.graph.getDependencide(this.url, this._dependencide)
+        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)
+        const interpreter = this.getInterpreter<ServiceSchedulerInterpreter>(descriptor)
+        interpreter.install(descriptor)
+    }
+
+    unlisten() {
+        const descriptor = this.variableProxy.get<ServiceSchedulerDescriptor>(this.scheduler.uuid, this)
+        const interpreter = this.getInterpreter<ServiceSchedulerInterpreter>(descriptor)
+        interpreter.uninstall(descriptor)
+
+        const master = this.unitCollection.get(this.scheduler.uuid) as Unit
+        const assets = [...this._assetCollection.values(), master]
+
+        for (const asset of assets) {
+            const unit = this.removeRoot(asset.queue.url)
+            if (unit === null) continue
+            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)
+
+        observer.unlisten('add', this.addWatcher)
+        observer.unlisten('remove', this.removeWatcher)
+        observer.unlisten('update', this.updateWatcher)
+        observer.unlisten('updateDeps', this.updateDepsWatcher)
+        observer.unlisten('free', this.freeWatcher)
+
+        this._dependencide.clear()
+    }
+
+    process() {
+        for (const unit of this._freeQueue) this.doFree(unit)
+        this._freeQueue.length = 0
+
+        this.updateStaticAsset()
+
+        this._dependencide.clear()
+        Asset.graph.getDependencide(this.url, this._dependencide)
+        Asset.activate(...this._dependencide.all, this.url)
+        const patch = this.diffAsset()
+
+        for (const removeAsset of patch.removeQueue) {
+            const unit = this.removeRoot(removeAsset)
+            if (unit !== null) unit.queue.iterator(operation => this.do(operation))
+            this._assetCollection.delete(removeAsset)
+        }
+        for (const addAsset of patch.addQueue) {
+            const root = Asset.get<Descriptor>(addAsset)
+            if (root instanceof Descriptor) {
+                this._assetCollection.set(addAsset, this.addRoot(addAsset, root))
+            }
+        }
+
+        const assets: Unit[] = []
+        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)
+            assets.push(unit)
+        })
+        assets.push(...this._staticAssetQueue)
+
+        for (const asset of assets) {
+            asset.queue.iterator(operation => this.do(operation))
+        }
+
+        const master = this.unitCollection.get(this.scheduler.uuid)
+        if (master === undefined) return
+
+        master.queue.iterator(operation => this.do(operation))
+
+        for (const asset of assets) {
+            asset.queue.iterator(unit => this.doUpdate(unit), 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)
+        }
+
+        this._freeQueue.push(...this._freeCollection.values())
+        this._freeCollection.clear()
+    }
+
+    clear() {
+        for (const service of this._services) {
+            const descriptor = this.variableProxy.get<ServiceDescriptor>(service.uuid, this)
+            const interpreter = this.getInterpreter<ServiceInterpreter>(descriptor)
+            interpreter.clear(descriptor)
+        }
+    }
+
+    beforeRender() {
+        for (const service of this._services) {
+            const descriptor = this.variableProxy.get<ServiceDescriptor>(service.uuid, this)
+            const interpreter = this.getInterpreter<ServiceInterpreter>(descriptor)
+            interpreter.beforeRender(descriptor)
+        }
+    }
+
+    render() {
+        for (const service of this._services) {
+            const descriptor = this.variableProxy.get<ServiceDescriptor>(service.uuid, this)
+            const interpreter = this.getInterpreter<ServiceInterpreter>(descriptor)
+            interpreter.render(descriptor)
+        }
+    }
+
+    afterRender() {
+        for (const service of this._services) {
+            const descriptor = this.variableProxy.get<ServiceDescriptor>(service.uuid, this)
+            const interpreter = this.getInterpreter<ServiceInterpreter>(descriptor)
+            interpreter.afterRender(descriptor)
+        }
+    }
+
+    addRoot(asset: string, root: Descriptor) {
+        const unit = new Unit(root.uuid, '', new Queue(asset))
+        this.unitCollection.set(unit)
+        this._freeCollection.delete(unit.uuid)
+
+        unit.trigger(Queue.Update)
+        for (const sub of root.children) {
+            observer.trigger('add', { self: sub.uuid, puid: root.uuid })
+        }
+
+        return unit
+    }
+    removeRoot(asset: string) {
+        const root = Asset.get<Descriptor>(asset)
+        const unit = this.unitCollection.get(root.uuid)
+        if (unit === undefined) return null
+        this.unitCollection.delete(unit.uuid)
+        unit.queue.clear()
+
+        this._freeCollection.set(unit.uuid, unit)
+        for (const sub of root.children) {
+            observer.trigger('remove', { self: sub.uuid, puid: root.uuid })
+        }
+
+        return unit
+    }
+
+    private addWatcher = (args: WatcherArgs) => {
+        const pUnit = this.unitCollection.get(args.puid)
+        if (pUnit === undefined) return
+        this.addCallback(args, pUnit)
+        const descriptor = Descriptor.get<Descriptor>(args.self)
+        descriptor.traverse(sub => observer.trigger('update', { self: sub.uuid }))
+    }
+    private removeWatcher = (args: WatcherArgs) => {
+        const unit = this.unitCollection.get(args.self)
+        if (unit === undefined) return
+        this.removeCallback(args)
+    }
+    private updateWatcher = (args: UpdateWatcherArgs) => {
+        const unit = this.unitCollection.get(args.self)
+        if (unit === undefined) return
+        const descriptor = Descriptor.get<Descriptor>(args.self)
+        this.variableProxy.update(descriptor)
+        unit.trigger(Queue.Update)
+    }
+    private updateDepsWatcher = (args: UpdateDepsWatcherArgs) => {
+        const unit = this.unitCollection.get(args.self)
+        if (unit === undefined) return
+
+        const deps = Asset.graph.getDependents(unit.queue.url)
+        for (const dep of deps) {
+            for (const port of dep.ports) {
+                if (Asset.graph.hasAssetReference(port, unit.queue.url)) {
+                    observer.trigger('update', { self: port.descriptor })
+                }
+            }
+        }
+    }
+    private freeWatcher = (args: UpdateWatcherArgs) => {
+        let unit = this.unitCollection.get(args.self)
+
+        if (unit === undefined) {
+            unit = this._freeCollection.get(args.self)
+            if (unit === undefined) return
+            this._freeCollection.delete(args.self)
+        }
+
+        this._freeQueue.push(unit)
+    }
+
+    private addCallback(args: WatcherArgs, pUnit: Unit) {
+        const parentDescriptor = Descriptor.get<Descriptor>(pUnit.uuid)
+        const descriptor = Descriptor.get<Descriptor>(args.self)
+        descriptor.traverse((sub, parent) => {
+            const unit = new Unit(sub.uuid, parent.uuid, pUnit.queue)
+            this.unitCollection.set(unit)
+            unit.trigger(Queue.Add)
+            this._freeCollection.delete(unit.uuid)
+        }, false, parentDescriptor)
+    }
+    private removeCallback(args: WatcherArgs) {
+        const descriptor = Descriptor.get<Descriptor>(args.self)
+        descriptor.traverse((sub) => {
+            const unit = this.unitCollection.get(sub.uuid)
+            if (unit === undefined) return
+            this.unitCollection.delete(sub.uuid)
+            unit.trigger(Queue.Remove)
+            this._freeCollection.set(unit.uuid, unit)
+        })
+    }
+
+    private updateStaticAsset() {
+        if (this.scheduler.camera !== this._currentCamera) {
+            const descriptor = Descriptor.get<Descriptor>(this.scheduler.camera)
+            if (descriptor === null) return
+            const oldNode = this.unitCollection.get(this._currentCamera)
+            if (oldNode) {
+                this.unitCollection.delete(this._currentCamera)
+                this._freeCollection.set(oldNode.uuid, oldNode)
+                ArrayUtils.remove(this._staticAssetQueue, oldNode)
+            }
+            const newNode = new Unit(descriptor.uuid, '', new Queue(Asset.createVirtualUrl('graphics/camera.ts')))
+            this.unitCollection.set(newNode)
+            ArrayUtils.insert(this._staticAssetQueue, newNode)
+            this._currentCamera = this.scheduler.camera
+        }
+    }
+
+    private diffAsset() {
+        const temp = new Map(this._assetCollection)
+        const addQueue: string[] = [], removeQueue: string[] = []
+
+        this._dependencide.forEachForGraphics(asset => {
+            temp.has(asset) ? temp.delete(asset) : addQueue.push(asset)
+        })
+        removeQueue.push(...temp.keys())
+
+        return { addQueue, removeQueue }
+    }
+
+    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)
+        const interpreter = this.getInterpreter(descriptor)
+
+        if (descriptor instanceof ServiceDescriptor) ArrayUtils.insert(this._services, descriptor)
+
+        interpreter.mount(descriptor, parentInterpreter, parentDescriptor)
+    }
+
+    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)
+        const interpreter = this.getInterpreter(descriptor)
+
+        if (descriptor instanceof ServiceDescriptor) ArrayUtils.remove(this._services, descriptor)
+
+        interpreter.unmount(descriptor, parentInterpreter, parentDescriptor)
+    }
+
+    getUnit<T extends Unit | null = Unit>(uuid: string) {
+        return (this.unitCollection.get(uuid) ?? null) as T
+    }
+
+    do(operation: Operation) {
+        switch (operation.type) {
+            case Queue.Add:
+                this.onMount(operation.unit)
+                break;
+            case Queue.Remove:
+                this.onUnmount(operation.unit)
+                break;
+            default:
+                console.log('do', operation.type)
+                break;
+        }
+    }
+
+    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) : override(descriptor, interpreter)
+    }
+
+    doFree(unit: Unit) {
+        const interpreter = this._interpreterCollection.get(unit.uuid)
+        if (interpreter === undefined) return
+        const descriptor = this.variableProxy.get<Descriptor>(unit.uuid, this)
+        interpreter.free(descriptor)
+        this._interpreterCollection.delete(unit.uuid)
+    }
+
+    getInterpreter<T extends Interpreter = Interpreter>(descriptor: Descriptor) {
+        let interpreter = this._interpreterCollection.get(descriptor.uuid) as T
+        if (interpreter === undefined) {
+            interpreter = Graphics.createInterpreter(descriptor, this)
+            this._interpreterCollection.set(descriptor.uuid, interpreter)
+        }
+        return interpreter
+    }
+
+    getParent<T extends Descriptor = Descriptor>(uuid: string) {
+        const unit = this.unitCollection.get(uuid)
+        if (unit === undefined) return null
+        return Descriptor.get<T>(unit.parent)
+    }
+
+    getActor<T extends Actor = Actor>(descriptor: Descriptor) {
+        const interpreter = this.getInterpreter(descriptor)
+        return interpreter.getActor<T>(descriptor)
+    }
+
+    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, result)
+    }
+    private _pickupScene(result: PickupObject[]) {
+        const master = this.unitCollection.get(this.scheduler.uuid)
+        if (master === undefined) return result
+
+        const units = this.unitCollection.values()
+        for (const unit of units) {
+            const descriptor = Descriptor.get<Descriptor>(unit.uuid)
+            if (descriptor instanceof HTMLDescriptor) continue
+            this._pickupItem(descriptor, result)
+        }
+    }
+
+    getMouseAndRect(event: MouseEvent) {
+        //@ts-ignore
+        const rect = event.target.getBoundingClientRect()
+        const mouse = { x: event.clientX - rect.left, y: event.clientY - rect.top }
+        return { mouse, rect }
+    }
+
+    traceService(target: Descriptor): ServiceDescriptor | null {
+        if (target instanceof ServiceDescriptor) return target
+
+        const parent = this.getParent(target.uuid)
+        if (parent === null) return null
+
+        return this.traceService(parent)
+    }
+
+    pickup(event: MouseEvent) {
+        const result: PickupObject[] = []
+
+        const isElement = event.target instanceof Element
+        if (isElement === false) return result
+        const uuid = event.target.getAttribute('data-vyr-uuid')
+        if (uuid === null) return result
+
+        const { mouse, rect } = this.getMouseAndRect(event)
+        const target = Descriptor.get<Descriptor>(uuid)
+        const args = { delta: 0 }
+        if (target instanceof ServiceDescriptor) {
+            if (target instanceof HTMLServiceDescriptor) {
+                this._pickupItem(target, result)
+            } else {
+                const interpreter = this.getInterpreter<ServiceInterpreter>(target)
+                interpreter.beforePickup(mouse, rect)
+                this._pickupScene(result)
+                interpreter.orderBy(result)
+            }
+        } else {
+            this._pickupItem(target, result)
+        }
+
+        return result
+    }
+
+    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) await current.execute(inter.inputs, this, descriptor)
+                break
+            }
+        }
+    }
+
+    setOverrideByUpdate(uuid: string, override: OverrideUpdate) {
+        this._overwriteUpdate.set(uuid, override)
+    }
+    deleteOverrideByUpdate(uuid: string) {
+        this._overwriteUpdate.delete(uuid)
+    }
+}
+
+export {
+    PickupObject,
+    TickArgs,
+    Graphics,
+}

package/output/engine/src/graphics/Observer.ts

@@ -0,0 +1,36 @@
+import { Listener } from "../Listener"
+
+interface WatcherArgs {
+    self: string
+    puid: string
+}
+
+interface UpdateWatcherArgs {
+    self: string
+}
+
+interface UpdateDepsWatcherArgs {
+    self: string
+}
+
+interface FreeWatcherArgs {
+    self: string
+}
+
+interface Observer {
+    add(args: WatcherArgs): void
+    remove(args: WatcherArgs): void
+    update(args: UpdateWatcherArgs): void
+    updateDeps(args: UpdateDepsWatcherArgs): void
+    free(args: FreeWatcherArgs): void
+}
+
+const observer = new Listener<Observer>()
+
+export {
+    WatcherArgs,
+    UpdateWatcherArgs,
+    UpdateDepsWatcherArgs,
+    FreeWatcherArgs,
+    observer,
+}

package/output/engine/src/graphics/Unit.ts

@@ -0,0 +1,83 @@
+import { ArrayUtils } from "../ArrayUtils"
+
+interface Operation {
+    type: number
+    unit: Unit
+}
+
+class Queue {
+    static readonly Add = 1
+    static readonly Remove = 2
+    static readonly Update = 3
+    readonly url: string
+    readonly operationCollection: Operation[] = []
+    readonly updateCollection: Unit[] = []
+
+    constructor(url: string) {
+        this.url = url
+    }
+
+    iterator<T extends Operation>(cb: (unit: T) => void): T[]
+    iterator<T extends Unit>(cb: (unit: T) => void, type: number): T[]
+    iterator<T extends Operation | Unit>(cb: (unit: T) => void, type?: number) {
+        let queue
+        switch (type) {
+            case Queue.Update:
+                queue = [...this.updateCollection]
+                this.updateCollection.length = 0
+                break
+            default:
+                queue = [...this.operationCollection]
+                this.operationCollection.length = 0
+                break
+        }
+        for (const unit of queue) cb(unit as any)
+
+        return queue as T[]
+    }
+
+    clear(type?: number) {
+        let queue
+        switch (type) {
+            case Queue.Update:
+                queue = this.updateCollection
+                break
+            default:
+                queue = this.operationCollection
+                break
+        }
+        queue.length = 0
+    }
+}
+
+class Unit {
+    uuid: string
+    parent: string
+    queue: Queue
+
+    constructor(uuid: string, parent: string, queue: Queue) {
+        this.uuid = uuid
+        this.parent = parent
+        this.queue = queue
+    }
+
+    trigger(type: number) {
+        switch (type) {
+            case Queue.Add:
+                this.queue.operationCollection.push({ type, unit: this })
+                break
+            case Queue.Remove:
+                this.queue.operationCollection.push({ type, unit: this })
+                break
+            case Queue.Update:
+                ArrayUtils.insert(this.queue.updateCollection, this)
+                break
+        }
+    }
+}
+
+export {
+    Operation,
+    Queue,
+    Unit,
+}

package/output/engine/src/graphics/VariableProxy.ts

@@ -0,0 +1,92 @@
+import { ObjectUtils } from "../ObjectUtils";
+import { Asset } from "../asset";
+import { Scriptable, ScriptableArgs } from "../interaction/Scriptable";
+import { Data, DatasetDescriptor, Descriptor, VariabConfig } from "../descriptor";
+import { Graphics } from "./Graphics";
+
+interface ActorCollection { [k: string]: any }
+
+interface Variables { [k: string]: any }
+
+class VariableProxy {
+    private readonly proxyCollection = new Map<Descriptor, any>()
+    private readonly variablesCollection = new Map<Descriptor, Variables>()
+
+    private createNestedProxy = (current: ActorCollection, root: Descriptor, currentPath = '') => {
+        return new Proxy(current, {
+            get: (target, prop: string) => {
+                if (typeof prop === 'symbol') return Reflect.get(target, prop)
+
+                const fullPath = currentPath ? `${currentPath}.${prop}` : prop
+                const variables = this.variablesCollection.get(root) as Variables
+
+                if (variables[fullPath] !== undefined) {
+                    return variables[fullPath]
+                }
+
+                const value = Reflect.get(target, prop)
+
+                if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+                    return this.createNestedProxy(value, root, fullPath)
+                }
+
+                return value
+            }
+        });
+    }
+    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<ScriptableArgs<undefined, undefined, undefined>>>(config.value)
+            if (scriptable === null) return
+            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) {
+        const descriptor = Descriptor.get<Descriptor>(uuid)
+        if (descriptor === null) return null as unknown as T
+
+        let proxy = this.proxyCollection.get(descriptor)
+        let variables = this.variablesCollection.get(descriptor)
+
+        if (variables === undefined || variables.version > 0) {
+            variables = Object.create(null) as Variables
+            variables.version = 0
+
+            const data = DatasetDescriptor.getData(descriptor.dataset)
+
+            if (data !== null) {
+                const keys = Object.keys(descriptor.variables)
+                for (const key of keys) {
+                    const variable = descriptor.variables[key]
+                    if (variable.enabled === false) continue
+                    const value = this.getVariableValue(descriptor, data, key, variable, graphics)
+                    if (value === undefined) continue
+                    variables[key] = value
+                }
+            }
+
+            this.variablesCollection.set(descriptor, variables)
+            proxy = this.createNestedProxy(descriptor, descriptor)
+            this.proxyCollection.set(descriptor, proxy)
+        } else if (proxy === undefined) {
+            proxy = this.createNestedProxy(descriptor, descriptor)
+            this.proxyCollection.set(descriptor, proxy)
+        }
+
+        return proxy as T
+    }
+
+    update(descriptor: Descriptor) {
+        const variables = this.variablesCollection.get(descriptor)
+        if (variables !== undefined) variables.version++
+    }
+}
+
+export {
+    Variables,
+    VariableProxy
+}

package/output/engine/src/graphics/index.ts

@@ -0,0 +1,5 @@
+export * from './Observer'
+export * from './Unit'
+export * from './VariableProxy'
+export * from './Graphics'
+export * from './Compilation'