@vyr/cli 0.0.12 → 0.0.13

package/output/engine/src/Color.ts

@@ -0,0 +1,111 @@
+import tinycolor from "tinycolor2"
+import { DeserializationObject, Serialization } from "./Serialization"
+
+class Color extends tinycolor { }
+
+interface ColorItem {
+    value: string
+    opacity: number
+    ratio: number
+}
+
+class BasicStyleColor {
+    static type = 'basic'
+    static create(color: DeserializationObject<BasicStyleColor>) {
+        switch (color.type) {
+            case "linear":
+                return new LinearStyleColor(color as LinearStyleColor)
+            case "radial":
+                return new RadialStyleColor(color as RadialStyleColor)
+            default:
+                return new DefaultStyleColor(color as DefaultStyleColor)
+        }
+    }
+    static getColor(color: BasicStyleColor) {
+        return 'rgba(0,0,0,0)'
+    }
+    type: string
+
+    constructor() {
+        this.type = (this.constructor as typeof BasicStyleColor).type
+    }
+
+    getColor() {
+        return (this.constructor as typeof BasicStyleColor).getColor(this)
+    }
+
+}
+
+class DefaultStyleColor extends BasicStyleColor {
+    static type = 'default'
+    static getColor(color: DefaultStyleColor) {
+        return new Color(color.value).setAlpha(color.opacity).toRgbString()
+    }
+    declare type: 'default'
+    value: string
+    opacity: number
+
+    constructor(color: Partial<DeserializationObject<DefaultStyleColor>> = {}) {
+        super()
+        this.value = color.value ?? '#ffffff'
+        this.opacity = color.opacity ?? 1
+    }
+}
+
+class LinearStyleColor extends BasicStyleColor {
+    static type = 'linear'
+    static getColor(color: LinearStyleColor) {
+        let items = ''
+        for (const item of color.value) {
+            items += `, ${new Color(item.value).setAlpha(item.opacity).toRgbString()} ${item.ratio * 100}%`
+        }
+
+        return `linear-gradient(${color.angle}deg ${items})`
+    }
+    declare type: 'linear'
+    angle: number
+    value: ColorItem[]
+    constructor(color: Partial<DeserializationObject<LinearStyleColor>> = {}) {
+        super()
+        this.angle = color.angle ?? 0
+        this.value = color.value ? Serialization.deepClone(color.value) : [{ value: '#ffffff', opacity: 1, ratio: 0 }, { value: '#ffffff', opacity: 1, ratio: 1 }]
+    }
+
+}
+
+class RadialStyleColor extends BasicStyleColor {
+    static type = 'radial'
+    static getColor(color: RadialStyleColor) {
+        let radis = ''
+        if (color.radius < 0) {
+            radis = 'farthest-corner'
+        } else {
+            radis = `${color.radius}px`
+        }
+
+        let center = ''
+        center = `${color.center.x * 100}% ${color.center.y * 100}%`
+
+        let items = ''
+        for (const item of color.value) {
+            items += `, ${new Color(item.value).setAlpha(item.opacity).toRgbString()} ${item.ratio * 100}%`
+        }
+
+        return `radial-gradient(circle ${radis} at ${center} ${items})`
+    }
+    declare type: 'radial'
+    center: { x: number; y: number }
+    radius: number
+    value: ColorItem[]
+
+    constructor(color: Partial<DeserializationObject<RadialStyleColor>> = {}) {
+        super()
+        this.center = color.center ? Serialization.deepClone(color.center) : { x: 0.5, y: 0.5 }
+        this.radius = color.radius ?? -1
+        this.value = color.value ? Serialization.deepClone(color.value) : [{ value: '#ffffff', opacity: 1, ratio: 0 }, { value: '#ffffff', opacity: 1, ratio: 1 }]
+    }
+}
+
+type StyleColor = DefaultStyleColor | LinearStyleColor | RadialStyleColor
+
+export { ColorItem, BasicStyleColor, DefaultStyleColor, LinearStyleColor, RadialStyleColor, StyleColor, Color }

package/output/engine/src/Engine.ts

@@ -0,0 +1,115 @@
+import { language } from './locale'
+import { Asset } from './asset'
+import { ServiceSchedulerDescriptor, StyleDescriptor } from './descriptor'
+import { Generate } from './Generate'
+import { InputSystem } from './InputSystem'
+import { Listener } from './Listener'
+import { Compilation, TickArgs } from './graphics'
+import { setupStyle } from './setup';
+
+interface EngineData { }
+
+interface EngineListener {
+  beforeRender: (args: TickArgs) => void
+  afterRender: (args: TickArgs) => void
+}
+
+class Engine extends Listener<EngineListener> {
+  private compilation = new Compilation()
+  private active = ''
+  private prevTimestamp = 0
+  private frame = 0
+
+  readonly uuid = Generate.uuid()
+  readonly DOM = document.createElement('div')
+  readonly inputSystem = new InputSystem(this.DOM)
+
+  constructor(data: Partial<EngineData> = {}) {
+    super()
+    this.DOM.style.width = '100%'
+    this.DOM.style.height = '100%'
+    this.DOM.style.position = 'relative'
+    this.DOM.style.top = '0'
+    this.DOM.style.left = '0'
+    this.DOM.style.overflow = 'hidden'
+    this.DOM.classList.add('vyr-engine', StyleDescriptor.basicName)
+    this.DOM.setAttribute('data-vyr', `vyr-engine`)
+    this.DOM.addEventListener('contextmenu', (e) => e.preventDefault())
+  }
+
+  private getDelta(timestamp: number) {
+    return (timestamp - this.prevTimestamp) / 1000
+  }
+
+  private tick(timestamp: number) {
+    const delta = this.getDelta(timestamp)
+    this.prevTimestamp = timestamp
+    this.frame = requestAnimationFrame((nextTimestamp) => this.tick(nextTimestamp))
+
+    const args = { delta }
+
+    this.compilation.foreach(graphics => graphics.args = args)
+
+    this.inputSystem.process()
+
+    this.compilation.process(this, args)
+  }
+
+  run(el: string | HTMLElement) {
+    if (this.frame !== 0) return
+
+    if (typeof el === 'string') {
+      const ele = document.getElementById(el)
+      if (ele === null) throw language.get('engine.run.container.notFound')
+      el = ele
+    }
+    el.appendChild(this.DOM)
+    setupStyle()
+
+    this.prevTimestamp = performance.now()
+    this.tick(this.prevTimestamp)
+  }
+
+  stop() {
+    if (this.frame === 0) return
+
+    cancelAnimationFrame(this.frame)
+    this.frame = 0
+  }
+
+  switch(scheduler: ServiceSchedulerDescriptor) {
+    const url = Asset.getUrlByUuid(scheduler.uuid)
+
+    if (!url) throw language.get('engine.switch.url.notFound')
+
+    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'))
+
+    const args = { delta: 0 }
+
+    this.compilation.foreach(graphics => graphics.args = args)
+
+    this.compilation.process(this, args)
+  }
+
+  clear() {
+    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/output/engine/src/Generate.ts

@@ -0,0 +1,40 @@
+let id = 1;
+const _lut = ['00', '01', '02', '03', '04', '05', '06', '07', '08', '09', '0a', '0b', '0c', '0d', '0e', '0f', '10', '11', '12', '13', '14', '15', '16', '17', '18', '19', '1a', '1b', '1c', '1d', '1e', '1f', '20', '21', '22', '23', '24', '25', '26', '27', '28', '29', '2a', '2b', '2c', '2d', '2e', '2f', '30', '31', '32', '33', '34', '35', '36', '37', '38', '39', '3a', '3b', '3c', '3d', '3e', '3f', '40', '41', '42', '43', '44', '45', '46', '47', '48', '49', '4a', '4b', '4c', '4d', '4e', '4f', '50', '51', '52', '53', '54', '55', '56', '57', '58', '59', '5a', '5b', '5c', '5d', '5e', '5f', '60', '61', '62', '63', '64', '65', '66', '67', '68', '69', '6a', '6b', '6c', '6d', '6e', '6f', '70', '71', '72', '73', '74', '75', '76', '77', '78', '79', '7a', '7b', '7c', '7d', '7e', '7f', '80', '81', '82', '83', '84', '85', '86', '87', '88', '89', '8a', '8b', '8c', '8d', '8e', '8f', '90', '91', '92', '93', '94', '95', '96', '97', '98', '99', '9a', '9b', '9c', '9d', '9e', '9f', 'a0', 'a1', 'a2', 'a3', 'a4', 'a5', 'a6', 'a7', 'a8', 'a9', 'aa', 'ab', 'ac', 'ad', 'ae', 'af', 'b0', 'b1', 'b2', 'b3', 'b4', 'b5', 'b6', 'b7', 'b8', 'b9', 'ba', 'bb', 'bc', 'bd', 'be', 'bf', 'c0', 'c1', 'c2', 'c3', 'c4', 'c5', 'c6', 'c7', 'c8', 'c9', 'ca', 'cb', 'cc', 'cd', 'ce', 'cf', 'd0', 'd1', 'd2', 'd3', 'd4', 'd5', 'd6', 'd7', 'd8', 'd9', 'da', 'db', 'dc', 'dd', 'de', 'df', 'e0', 'e1', 'e2', 'e3', 'e4', 'e5', 'e6', 'e7', 'e8', 'e9', 'ea', 'eb', 'ec', 'ed', 'ee', 'ef', 'f0', 'f1', 'f2', 'f3', 'f4', 'f5', 'f6', 'f7', 'f8', 'f9', 'fa', 'fb', 'fc', 'fd', 'fe', 'ff'];
+
+class Generate {
+  static id() {
+    return id++
+  }
+
+  static uuid() {
+    const d0 = Math.random() * 0xffffffff | 0;
+    const d1 = Math.random() * 0xffffffff | 0;
+    const d2 = Math.random() * 0xffffffff | 0;
+    const d3 = Math.random() * 0xffffffff | 0;
+    const uuid = _lut[d0 & 0xff] + _lut[d0 >> 8 & 0xff] + _lut[d0 >> 16 & 0xff] + _lut[d0 >> 24 & 0xff] + '-' +
+      _lut[d1 & 0xff] + _lut[d1 >> 8 & 0xff] + '-' + _lut[d1 >> 16 & 0x0f | 0x40] + _lut[d1 >> 24 & 0xff] + '-' +
+      _lut[d2 & 0x3f | 0x80] + _lut[d2 >> 8 & 0xff] + '-' + _lut[d2 >> 16 & 0xff] + _lut[d2 >> 24 & 0xff] +
+      _lut[d3 & 0xff] + _lut[d3 >> 8 & 0xff] + _lut[d3 >> 16 & 0xff] + _lut[d3 >> 24 & 0xff];
+
+    return uuid.toLowerCase()
+  }
+
+  static delayExecute(cb: (...args: any[]) => any) {
+    const delaySatate = {
+      args: [] as any[],
+      execute: false
+    }
+    const execute = (...args: any[]) => {
+      delaySatate.args = args
+      if (delaySatate.execute === true) return
+      delaySatate.execute = true
+      requestAnimationFrame(() => {
+        cb(...delaySatate.args)
+        delaySatate.execute = false
+      })
+    }
+    return execute
+  }
+}
+
+export { Generate }

package/output/engine/src/InputSystem.ts

@@ -0,0 +1,108 @@
+type IEM = GlobalEventHandlersEventMap
+
+interface InputConfig {
+  /**事件只触发一次，默认`false` */
+  once: boolean
+  /**将事件的处理顺序设为事件捕获，默认`false` */
+  capture: boolean
+  /**处理函数不会调用`preventDefault`来阻止默认行为时应设为true，默认`false` */
+  passive: boolean
+  /**事件触发的对象 */
+  target: Window | Document | HTMLElement
+}
+
+const privateState = {
+  id: 1,
+  listener: {
+    default: (input: InputEvent, system: InputSystem) => {
+      return (event: Event) => {
+        input.event = event
+        if (input.enable) return
+        input.enable = true
+        system.quaua.push(input)
+      }
+    },
+    once: (input: InputEvent, system: InputSystem) => {
+      const execute = privateState.listener.default(input, system)
+      return (e: Event) => {
+        execute(e)
+        system.unlisten(input.id)
+      }
+    },
+  }
+}
+
+class InputEvent {
+  readonly id = privateState.id++
+  readonly type
+  readonly target
+  readonly callback: (e: Event) => void
+  readonly listener: (e: Event) => void
+  enable = false
+  event!: Event
+
+  constructor(type: keyof IEM, callback: (e: any) => void, system: InputSystem, config: InputConfig) {
+    this.type = type
+    this.target = config.target
+    this.callback = callback
+    this.listener = config.once ? privateState.listener.once(this, system) : privateState.listener.default(this, system)
+  }
+
+  execute() {
+    this.callback(this.event)
+    this.enable = false
+  }
+}
+
+class InputSystem {
+  private _target
+  private _registry: InputEvent[] = []
+  readonly quaua: InputEvent[] = []
+
+  constructor(target: InputConfig['target']) {
+    this._target = target
+  }
+
+  /**
+   * 监听事件输入,事件在一帧中只执行一次
+   * @param type 事件类型
+   * @param callback 事件触发时的回调
+   * @param options.once 只执行一次回调
+   * @param options.target 监听事件的绑定对象
+   * @param options.capture 事件执行的阶段，true：捕获阶段执行，false：冒泡阶段执行
+   */
+  listen<T extends keyof IEM>(type: T, callback: (event: IEM[T]) => void, options: Partial<InputConfig> = {}) {
+    const config: InputConfig = { once: false, target: this._target, passive: false, capture: false, ...options }
+
+    for (const input of this._registry) {
+      if (input.type === type && input.callback === callback && options.target === input.target) return input.id
+    }
+
+    const input = new InputEvent(type, callback, this, config)
+    this._registry.push(input)
+    input.target.addEventListener(type, input.listener, config.capture)
+
+    return input.id
+  }
+
+  /**解除事件监听 */
+  unlisten(id: number) {
+    for (let i = 0; i < this._registry.length; i++) {
+      const input = this._registry[i]
+      if (input.id === id) {
+        this._registry.splice(i, 1)
+        input.target.removeEventListener(input.type, input.listener)
+        return
+      }
+    }
+  }
+
+  /**处理输入事件 */
+  process() {
+    const quaua = [...this.quaua]
+    for (const input of quaua) input.execute()
+    this.quaua.length = 0
+  }
+}
+
+export { InputSystem }

package/output/engine/src/Listener.ts

@@ -0,0 +1,59 @@
+type DeafultCallback = (...args: any[]) => any
+type CallbackCollection<T extends {} = {}> = { [k: string]: DeafultCallback } & T
+
+interface listenOptions {
+  once?: boolean
+  insertIndex?: number
+}
+
+class Listener<T extends {} = {}> {
+  private registrys: any = {}
+
+  listen<K extends keyof T>(type: K, callback: T[K], options?: listenOptions): () => void
+  listen(type: string, callback: DeafultCallback, options?: listenOptions): () => void
+  listen<K extends keyof T>(type: K | string, callback?: T[K], options: listenOptions = {}) {
+
+    let register = this.registrys[type]
+    if (register === undefined) {
+      register = []
+      this.registrys[type] = register
+    }
+    const insertIndex = options.insertIndex === undefined ? register.length : options.insertIndex
+
+    const row = register.find((r: any) => r.callback === callback)
+    if (!row) register.splice(insertIndex, 0, { once: options.once ?? false, callback })
+    const unlisten = () => this.unlisten(type as any, callback)
+    return unlisten
+  }
+
+  unlisten<K extends keyof T>(type: K, callback: T[K]): void
+  unlisten(type: string, callback: DeafultCallback): void
+  unlisten<K extends keyof T>(type: K, callback: T[K]) {
+    let registry = this.registrys[type]
+    if (registry === undefined) return
+
+    for (let i = 0; i < registry.length; i++) {
+      if (registry[i].callback !== callback) continue
+
+      registry.splice(i, 1)
+      if (registry.length === 0) delete this.registrys[type]
+      return
+    }
+  }
+
+  trigger<K extends keyof T>(type: K, ...args: Parameters<CallbackCollection<T>[K]>): void
+  trigger(type: string, ...args: any[]): void
+  trigger<K extends keyof T>(type: K, ...args: Parameters<CallbackCollection<T>[K]>) {
+    let registry = this.registrys[type]
+    if (registry === undefined) return //console.warn(`无法触发该事件 ${type as string}`)
+
+    if (registry.length === 0) return
+
+    registry = [...this.registrys[type]]
+    for (let i = 0; i < registry.length; i++) {
+      registry[i].callback(...args as any)
+      if (registry[i].once === true) this.unlisten(type, registry[i].callback)
+    }
+  }
+}
+export { Listener }

package/output/engine/src/ObjectPool.ts

@@ -0,0 +1,84 @@
+import { Generate } from "./Generate"
+
+const privateState = {
+  instances: new Map<string, WeakRef<ObjectPool>>(),
+  freeWatcher: [] as Array<(uuid: string) => void>,
+  monitoring: () => {
+    let currentIndex = 0
+
+    const loop = () => {
+      setTimeout(loop, 5000)
+
+      const uuids = [...privateState.instances.keys()]
+      const total = uuids.length
+
+      if (currentIndex >= total) currentIndex = 0
+
+      let count = 0
+      let startIndex = currentIndex
+      const startTime = performance.now()
+
+      while (count < 500 && performance.now() - startTime < 5) {
+        if (startIndex >= total) break
+        count++
+        const uuid = uuids[startIndex++]
+        ObjectPool.get(uuid) === null ? destroyInstance(uuid) : currentIndex++
+      }
+    }
+
+    loop()
+  },
+}
+
+const listenInstance = (type: 'free', watcher: (uuid: string) => void) => {
+  switch (type) {
+    case 'free':
+      privateState.freeWatcher.push(watcher)
+      break;
+    default:
+      break;
+  }
+}
+
+/**将实例销毁并回收相关资源 */
+const destroyInstance = (uuid: string) => {
+  const instance = privateState.instances.get(uuid)
+  if (instance === undefined) return
+  for (const free of privateState.freeWatcher) free(uuid)
+  privateState.instances.delete(uuid)
+}
+
+/**对象池
+ * 
+ * 以`uuid`为标识，同一个`uuid`只会存在一个实例
+ */
+class ObjectPool {
+  /**获取缓存实例 */
+  static get<T extends ObjectPool | null = ObjectPool | null>(uuid: string) {
+    const instance = privateState.instances.get(uuid)
+    if (instance === undefined) return null as T
+    return (instance.deref() ?? null) as T
+  }
+
+  readonly uuid!: string
+  /**
+   * @param uuid 实例的唯一标识
+   */
+  constructor(uuid = Generate.uuid()) {
+    const instance = ObjectPool.get(uuid)
+    if (instance !== null) {
+      instance.beenInstantiated(instance)
+      return instance
+    }
+    this.uuid = uuid
+
+    privateState.instances.set(uuid, new WeakRef(this))
+  }
+
+  /**若在初始化时发现已存在相同uuid的实例，则会调用该方法 */
+  protected beenInstantiated(instance: ObjectPool) { }
+}
+
+privateState.monitoring()
+
+export { listenInstance, destroyInstance, ObjectPool }

package/output/engine/src/ObjectUtils.ts

@@ -0,0 +1,49 @@
+import { ArrayUtils } from "./ArrayUtils"
+class ObjectUtils {
+
+    static equals(left: { [k: string]: any }, right: { [k: string]: any }, ignore: string[] = []) {
+        const keys = Object.keys(left)
+        const rkeys = Object.keys(right)
+        if (keys.length !== rkeys.length) return false
+        const rset = new Set(rkeys)
+        for (const key of keys) {
+            if (rset.has(key) === false) return false
+            if (ignore.includes(key)) continue
+
+            const value = left[key]
+            const t = typeof value
+
+            if (t === 'string' || t === 'boolean' || t === 'number' || t === 'bigint' || t === 'undefined' || t === 'symbol' || t === null) {
+                if (value !== right[key]) return false
+            }
+
+            if (Array.isArray(value)) {
+                if (ArrayUtils.equals(value, right[key], ignore) == false) return false
+                continue
+            }
+
+            if (t === 'object') {
+                if (ObjectUtils.equals(value, right[key], ignore) === false) return false
+                continue
+            }
+        }
+
+        return true
+    }
+
+    static parseKey(key: string) {
+        return key.split('.').filter(clip => clip !== '')
+    }
+    
+    static getValueByKey(target: { [k: string]: any }, key: string) {
+        if (!target) return
+        const keys = this.parseKey(key)
+        for (const key of keys) {
+            target = target[key]
+            if (target === undefined) return
+        }
+        return target
+    }
+}
+
+export { ObjectUtils }

package/output/engine/src/Serialization.ts

@@ -0,0 +1,49 @@
+interface SerializationObject {
+  [k: string]: any
+}
+
+type DeserializationObject<T extends { [k: string]: any } = { [k: string]: any }> = {
+  -readonly [K in keyof T as T[K] extends Function ? never : K]:
+  T[K] extends Array<infer U>
+  ? U extends { [k: string]: any }
+  ? Array<DeserializationObject<U>>
+  : T[K]
+  : T[K] extends object
+  ? DeserializationObject<T[K]>
+  : T[K]
+};
+
+const privateRules = [
+  { parse: Infinity, stringify: '__vyr_infinity+__', },
+  { parse: -Infinity, stringify: '__vyr_infinity-__', },
+]
+
+const privateToStringify = (key: string, value: any) => {
+  for (const rule of privateRules) {
+    if (rule.parse === value) return rule.stringify
+  }
+  return value
+}
+const privateToJson = (key: string, value: any) => {
+  for (const rule of privateRules) {
+    if (rule.stringify === value) return rule.parse
+  }
+  return value
+}
+
+class Serialization {
+
+  static stringify(obj: SerializationObject) {
+    return JSON.stringify(obj, privateToStringify)
+  }
+
+  static parse(str: string) {
+    return JSON.parse(str, privateToJson) as DeserializationObject
+  }
+
+  static deepClone<T extends any = any>(obj: SerializationObject) {
+    return this.parse(this.stringify(obj)) as T
+  }
+}
+
+export { SerializationObject, DeserializationObject, Serialization }

package/output/engine/src/Traverser.ts

@@ -0,0 +1,39 @@
+interface TraverseNode {
+    children: TraverseNode[]
+}
+interface PreItem<T extends TraverseNode = TraverseNode> {
+    parent: T | null
+    des: T
+}
+
+/**遍历器 */
+class Traverser {
+
+    /**前序遍历 */
+    static pre<T extends TraverseNode = TraverseNode, D extends T | null = null>(descriptor: T, cb: (sub: T, parent: D) => void, defaultParent: D = null as D) {
+        const whileQuaua: PreItem<T>[] = [{ parent: defaultParent, des: descriptor }]
+
+        while (whileQuaua.length > 0) {
+            const item = whileQuaua.pop() as PreItem<T>
+            cb(item.des, item.parent as D)
+            for (let i = item.des.children.length - 1; i >= 0; i--) {
+                whileQuaua.push({ parent: item.des, des: item.des.children[i] as T })
+            }
+        }
+    }
+
+    /**前序遍历且可以终止 */
+    static preTerminated<T extends TraverseNode = TraverseNode, D extends T | null = null>(descriptor: T, cb: (sub: T, parent: D) => true | void, defaultParent: D = null as D) {
+        const whileQuaua: PreItem<T>[] = [{ parent: defaultParent, des: descriptor }]
+
+        while (whileQuaua.length > 0) {
+            const item = whileQuaua.pop() as PreItem<T>
+            if (cb(item.des, item.parent as D) === true) continue
+            for (let i = item.des.children.length - 1; i >= 0; i--) {
+                whileQuaua.push({ parent: item.des, des: item.des.children[i] as T })
+            }
+        }
+    }
+}
+
+export { Traverser }

package/output/engine/src/actor/Actor.ts

@@ -0,0 +1,28 @@
+import { Graphics } from '../graphics/Graphics'
+
+const privateState = {
+    idBuilder: 0,
+    collection: new Map<number, Graphics>()
+}
+
+class Actor {
+    static seGraphics(actor: Actor, graphics: Graphics) {
+        privateState.collection.set(actor.id, graphics)
+    }
+    static getGraphics<T extends Graphics = Graphics>(actor: Actor) {
+        return (privateState.collection.get(actor.id) ?? null) as T
+    }
+    static deleteGraphics(actor: Actor) {
+        privateState.collection.delete(actor.id)
+    }
+    readonly id = privateState.idBuilder++
+    object?: any
+
+    add(actor: Actor) { }
+
+    remove(actor: Actor) { }
+}
+
+export {
+    Actor,
+}