@vyr/cli 0.0.12 → 0.0.13

package/output/engine/src/index.ts

@@ -0,0 +1,27 @@
+declare global {
+  interface SnowAssets { }
+}
+
+export * from './locale'
+export * from './math'
+export * from './Color'
+export * from './Serialization'
+export { Category } from './Category'
+export { ArrayUtils } from './ArrayUtils'
+export { ObjectUtils } from './ObjectUtils'
+export { Generate } from './Generate'
+export { Traverser } from './Traverser'
+export { Listener } from './Listener'
+export { InputSystem } from './InputSystem'
+export { destroyInstance } from './ObjectPool'
+export * from './AsyncTask'
+export * from './interaction/Scriptable'
+export * from './interaction'
+export * from './descriptor'
+export * from './interpreter'
+export * from './utils'
+export * from './actor'
+export * from './graphics'
+export * from './asset'
+export * from './preset'
+export * from './Engine'

package/output/engine/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,
+}

package/output/engine/src/interaction/InteractionExecutor.ts

@@ -0,0 +1,84 @@
+import { Asset } from "../asset"
+import { Scriptable } from "./Scriptable"
+import { InteractionDescriptor, InteractionInputCollection, InteractionNode } from "./InteractionDescriptor"
+import { Graphics } from "../graphics/Graphics"
+
+type ExecuteResult = { [k: string]: any } | null
+
+class InteractionExecutor {
+    readonly collection = new Map<string, InteractionNode>()
+    readonly linkCollection = new Map<string, string[]>()
+
+    update(interaction: InteractionDescriptor) {
+        this.collection.clear()
+        this.linkCollection.clear()
+
+        for (const node of interaction.nodes) {
+            this.collection.set(node.id, node)
+        }
+
+        for (const mapper of interaction.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, interaction: InteractionDescriptor, graphics: Graphics, result: Map<string, ExecuteResult>, trigger: any, otherArgs?: any) {
+        await this.doExecute(branch, previous, customInputs, interaction, graphics, result, trigger, otherArgs)
+    }
+
+    async doCondition(condition: string, previous: string, customInputs: InteractionInputCollection, interaction: InteractionDescriptor, graphics: Graphics, result: Map<string, ExecuteResult>, trigger: any, otherArgs?: any) {
+        const preResult = result.get(previous)
+        const conditionResult = result.get(condition)
+        if (preResult !== conditionResult?.condition.value) return
+
+        await this.doExecute(condition, previous, customInputs, interaction, graphics, result, trigger, otherArgs)
+    }
+
+    async doExecute(execute: string, previous: string, customInputs: InteractionInputCollection, interaction: InteractionDescriptor, graphics: Graphics, result: Map<string, ExecuteResult>, trigger: any, otherArgs?: any) {
+        const nexts = this.linkCollection.get(execute)
+        if (nexts === undefined) return
+
+        for (const next of nexts) {
+            await this.doNext(next, execute, customInputs, interaction, graphics, result, trigger, otherArgs)
+        }
+    }
+
+    async doNext(current: string, previous: string, customInputs: InteractionInputCollection, interaction: InteractionDescriptor, graphics: Graphics, result: Map<string, ExecuteResult>, trigger: any, otherArgs?: any) {
+        const active = this.collection.get(current)
+        if (active === undefined) return
+
+        const currentInput = customInputs[current] ?? {}
+        const script = Asset.get<Scriptable>(active.url)
+        if (script) {
+            const args = { input: { previous, default: active.input, user: currentInput }, result, trigger }
+            if (otherArgs) Object.assign(args, otherArgs)
+            const executeResult = await script.execute(graphics, args)
+            result.set(current, executeResult)
+        }
+
+        if (active.interaction === 'Branch') {
+            await this.doBranch(current, previous, customInputs, interaction, graphics, result, trigger, otherArgs)
+        } else if (active.interaction === 'Condition') {
+            if (result.has(current) === false) result.set(current, active.input)
+            await this.doCondition(current, previous, customInputs, interaction, graphics, result, trigger, otherArgs)
+        } else {
+            await this.doExecute(current, previous, customInputs, interaction, graphics, result, trigger, otherArgs)
+        }
+    }
+
+    async execute(customInputs: InteractionInputCollection, interaction: InteractionDescriptor, graphics: Graphics, trigger: any, otherArgs?: any) {
+        for (const root of interaction.roots) {
+            const resultCollection = new Map()
+            await this.doNext(root, '', customInputs, interaction, graphics, resultCollection, trigger, otherArgs)
+        }
+    }
+}
+
+export {
+    InteractionExecutor
+}

package/output/engine/src/interaction/Scriptable.ts

@@ -0,0 +1,40 @@
+import { Descriptor } from "../descriptor"
+import { Graphics } from "../graphics/Graphics"
+import { InteractionInput } from "./InteractionDescriptor";
+
+interface ScriptableInput<T = InteractionInput> {
+    previous: string;
+    default: T,
+    user: T
+}
+
+interface ScriptableArgs<T = InteractionInput, R = Map<string, any>, I = ScriptableInput<T>> {
+    input: I,
+    result: R,
+    trigger: Descriptor
+}
+
+/**
+ * 可编程脚本(脚本不会在服务端实例化)
+ */
+class Scriptable<T extends ScriptableArgs<any, any, any> = ScriptableArgs> {
+    readonly uuid
+    /**脚本文件的url路径 */
+    get url() {
+        return this.uuid
+    }
+
+    constructor(url: string) {
+        this.uuid = url
+    }
+
+    /**脚本的准备事件，该方法在脚本被实例化后立即执行
+     * 
+     * 一般在该事件中进行脚本的准备工作，如从服务端获取资源或数据
+     */
+    async ready() { }
+
+    execute(graphics: Graphics, args: T): any { }
+}
+
+export { ScriptableArgs, Scriptable }

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

@@ -0,0 +1,3 @@
+export * from './InteractionDescriptor'
+export * from './InteractionExecutor'
+export * from './Scriptable'

package/output/engine/src/interpreter/AnimationUnitInterpreter.ts

@@ -0,0 +1,53 @@
+import { AnimationUnitDescriptor, Descriptor } from '../descriptor';
+import { ArrayUtils } from '../ArrayUtils';
+import { Interpreter } from './Interpreter'
+import { AnimationUnitActor } from "../actor";
+
+const privateState = {
+    collection: [] as AnimationUnitActor[],
+}
+
+class AnimationUnitInterpreter extends Interpreter {
+    static type = AnimationUnitDescriptor.type
+    static enabled = true
+    static reset(time = 0) {
+        const enabled = AnimationUnitInterpreter.enabled
+        AnimationUnitInterpreter.enabled = true
+        for (const animationUnit of privateState.collection) {
+            animationUnit.reset(time)
+        }
+        AnimationUnitInterpreter.enabled = enabled
+    }
+
+    animationUnit: AnimationUnitActor | null = null
+
+    freeUnit() {
+        if (this.animationUnit === null) return
+        ArrayUtils.remove(privateState.collection, this.animationUnit)
+        this.animationUnit.unlisten()
+        this.animationUnit = null
+    }
+
+
+    update(descriptor: AnimationUnitDescriptor) {
+        super.update(descriptor)
+
+        this.freeUnit()
+
+        const parentDescriptor = AnimationUnitDescriptor.get<AnimationUnitDescriptor>(this.unit.parent)
+        if (parentDescriptor === null) return
+
+        this.animationUnit = AnimationUnitActor.parse(descriptor)
+        ArrayUtils.insert(privateState.collection, this.animationUnit)
+        this.animationUnit.setTarget(parentDescriptor)
+        this.animationUnit.listen(this.graphics)
+    }
+
+    unmount(descriptor: AnimationUnitDescriptor, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
+        this.freeUnit()
+        super.unmount(descriptor, parentInterpreter, parentDescriptor)
+    }
+}
+Interpreter.register(AnimationUnitInterpreter)
+
+export { AnimationUnitInterpreter }

package/output/engine/src/interpreter/DatasetInterpreter.ts

@@ -0,0 +1,11 @@
+import { DatasetDescriptor } from "../descriptor";
+import { Interpreter } from "./Interpreter";
+
+class DatasetInterpreter extends Interpreter {
+    static type = DatasetDescriptor.type
+}
+Interpreter.register(DatasetInterpreter)
+
+export {
+    DatasetInterpreter
+}

package/output/engine/src/interpreter/DivInterpreter.ts

@@ -0,0 +1,44 @@
+import { Descriptor, DivDescriptor } from "../descriptor"
+import { Interpreter } from "./Interpreter"
+import { DivActor, HTMLActor } from "../actor"
+import { PickupObject } from "../graphics"
+
+class DivInterpreter extends Interpreter {
+    static type = DivDescriptor.type
+
+    protected createActor(descriptor: DivDescriptor) {
+        return new DivActor(descriptor.uuid)
+    }
+
+    update(descriptor: DivDescriptor) {
+        super.update(descriptor)
+        const actor = this.getActor<DivActor>(descriptor)
+        actor.update(descriptor)
+    }
+
+    mount(descriptor: DivDescriptor, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
+        super.mount(descriptor, parentInterpreter, parentDescriptor)
+        const actor = this.getActor<DivActor>(descriptor)
+
+        const parenActor = parentInterpreter.getActor<HTMLActor>(parentDescriptor)
+        parenActor.add(actor)
+    }
+
+    unmount(descriptor: DivDescriptor, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
+        const actor = this.getActor<DivActor>(descriptor)
+        actor.clearStyleClass(actor.DOM)
+        actor.cleanInteraction()
+
+        const parenActor = parentInterpreter.getActor<HTMLActor>(parentDescriptor)
+        parenActor.remove(actor)
+
+        super.unmount(descriptor, parentInterpreter, parentDescriptor)
+    }
+
+    pickup(descriptor: DivDescriptor, result: PickupObject[]) {
+        result.push({ uuid: descriptor.uuid, generatedBy: descriptor.generatedBy })
+    }
+}
+Interpreter.register(DivInterpreter)
+
+export { DivInterpreter }

package/output/engine/src/interpreter/DynamicInterpreter.ts

@@ -0,0 +1,207 @@
+import { ArrayUtils } from "../ArrayUtils"
+import { Asset } from "../asset"
+import { DynamicDescriptor, Descriptor, Data, DatasetDescriptor, PrefabeDescriptor } from "../descriptor"
+import { observer, UpdateWatcherArgs, WatcherArgs } from "../graphics"
+import { Category } from "../Category"
+import { FragmentInterpreter, Interpreter } from "."
+
+class DynamicInterpreter extends FragmentInterpreter {
+    static type = DynamicDescriptor.type
+
+    private _currentDepth = 0
+    private _datasetCloneCollection = new Map<string, DatasetDescriptor>()
+    private _rawToCloneCollection = new Map<string, Descriptor[]>()
+    private _cloneCollection = new Map<number, Descriptor>()
+
+    private _getDataset(descriptor: Descriptor, dataCollection: Data, i: number) {
+        const url = Asset.createVirtualUrl(`dynamic/dataset/${descriptor.uuid}-${i}-${this._currentDepth}${Category.datasetSuffix}`)
+        if (this._datasetCloneCollection.has(url)) return url
+        const data = dataCollection[i]
+        const dataset = new DatasetDescriptor()
+        dataset.setExtraData({ index: i })
+        dataset.setData(data)
+        Asset.set(url, dataset)
+        this._datasetCloneCollection.set(url, dataset)
+        return url
+    }
+    private _getDataByDataset<T extends Data | null = Data | null>(url: string) {
+        const dataset = this._datasetCloneCollection.get(url)
+
+        return (dataset?.getData() ?? null) as T
+    }
+
+    private _setCache(raw: Descriptor, clone: Descriptor) {
+        let clones = this._rawToCloneCollection.get(raw.uuid)
+        if (clones === undefined) {
+            clones = []
+            this._rawToCloneCollection.set(raw.uuid, clones)
+        }
+        clones.push(clone)
+    }
+
+    private _markSubDynamic(raw: DynamicDescriptor, parent: Descriptor, generatedBy: string, map: Map<string, Descriptor>, childs: Descriptor[]) {
+        this._currentDepth += 1
+        const template = Asset.get<Descriptor>(raw.url)
+        if (raw.dataConfig === 2) {
+            const parentData = this._getDataByDataset(parent.dataset)
+            if (parentData === null || typeof parentData !== 'object') return
+            //TODO 使用路径解析工具，实现更强大属性支持
+            const pathData = parentData[raw.dataPath]
+            if (Array.isArray(pathData) === false || pathData.length === 0) return
+
+            for (let i = 0; i < pathData.length; i++) {
+                const dataset = this._getDataset(raw, pathData, i)
+                const clone = this._markAndClone(template, dataset, generatedBy, map, childs)
+                parent.add(clone)
+            }
+        } else {
+            const selfData = this._getDataByDataset(raw.dataset)
+            if (Array.isArray(selfData) === false || selfData.length === 0) return
+
+            for (let i = 0; i < selfData.length; i++) {
+                const dataset = this._getDataset(raw, selfData, i)
+                const clone = this._markAndClone(template, dataset, generatedBy, map, childs)
+                parent.add(clone)
+            }
+        }
+    }
+
+    private _markAndClone(raw: Descriptor, dataset: string, generatedBy: string, map: Map<string, Descriptor>, childs: Descriptor[]) {
+        let clone
+        if (raw instanceof DynamicDescriptor) {
+            clone = new Descriptor({ dataset })
+            if (raw.url) this._markSubDynamic(raw, clone, generatedBy, map, childs)
+        } else if (raw instanceof PrefabeDescriptor) {
+            clone = new Descriptor({ dataset })
+        } else {
+            clone = raw.clone(false)
+            clone.dataset = dataset
+            map.set(raw.uuid, clone)
+            if (clone.interactions.length > 0) childs.push(clone)
+        }
+
+        clone.generatedBy = generatedBy
+
+        for (const subRaw of raw.children) {
+            const subClone = this._markAndClone(subRaw, dataset, generatedBy, map, childs)
+            clone.add(subClone)
+        }
+
+        this._setCache(raw, clone)
+
+        return clone
+    }
+
+    private _onAdd = (args: WatcherArgs) => {
+        const clones = this._rawToCloneCollection.get(args.puid)
+        if (clones === undefined) return
+
+        const max = clones.length
+        const descriptor = Descriptor.get<Descriptor>(args.self)
+        for (let i = 0; i < max; i++) {
+            const clone = clones[i]
+            const map = new Map<string, Descriptor>()
+            const childs: Descriptor[] = []
+            const subClone = this._markAndClone(descriptor, clone.dataset, clone.generatedBy, map, childs)
+            Descriptor.fixReferences(childs, map)
+            clone.add(subClone)
+        }
+    }
+
+    private _onRemove = (args: WatcherArgs) => {
+        const clones = this._rawToCloneCollection.get(args.self)
+        if (clones === undefined) return
+
+        while (clones.length > 0) {
+            const clone = clones.pop()
+            if (clone === undefined) continue
+            const parent = this.graphics.getParent(clone.uuid)
+            if (parent === null) continue
+            parent.remove(clone)
+            ArrayUtils.remove(clones, clone)
+        }
+        const descriptor = Descriptor.get<Descriptor>(args.self)
+        descriptor.traverse(sub => {
+            this._rawToCloneCollection.delete(sub.uuid)
+        })
+    }
+
+    private _onUpdate = (args: UpdateWatcherArgs) => {
+        const clones = this._rawToCloneCollection.get(args.self)
+        if (clones === undefined) return
+
+        const raw = Descriptor.get<Descriptor>(args.self)
+        if (raw instanceof DynamicDescriptor) {
+            const ancestor = raw.traceAncestor()
+            if (ancestor.parent === null) return
+            const watcher = { self: args.self, puid: ancestor.parent.uuid }
+            this._onRemove(watcher)
+            this._onAdd(watcher)
+        } else {
+            for (const clone of clones) {
+                clone.syncWith(raw)
+                clone.setNeedsUpdate()
+            }
+        }
+    }
+
+    private _clearByOnUpdate = (args: WatcherArgs) => {
+        if (args.self !== this.unit.uuid) return
+
+        this._rawToCloneCollection.clear()
+        this._datasetCloneCollection.clear()
+
+        const clones = this._cloneCollection.values()
+        for (const clone of clones) {
+            observer.trigger('remove', { self: clone.uuid, puid: this.unit.uuid })
+        }
+        this._cloneCollection.clear()
+    }
+
+    mount(descriptor: Descriptor, parentInterpreter: Interpreter, parentDescriptor: Descriptor): void {
+        super.mount(descriptor, parentInterpreter, parentDescriptor)
+        observer.listen('update', this._clearByOnUpdate)
+    }
+
+    unmount(descriptor: Descriptor, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
+        observer.unlisten('update', this._clearByOnUpdate)
+        super.unmount(descriptor, parentInterpreter, parentDescriptor)
+    }
+
+    update(descriptor: DynamicDescriptor) {
+        super.update(descriptor)
+
+        observer.unlisten('add', this._onAdd)
+        observer.unlisten('remove', this._onRemove)
+        observer.unlisten('update', this._onUpdate)
+
+        if (descriptor.dataset && descriptor.url) {
+            const rootData = DatasetDescriptor.getCollection(descriptor.dataset)
+            if (rootData.length > 0) {
+                const template = Asset.get<Descriptor>(descriptor.url)
+                for (let i = 0; i < rootData.length; i++) {
+                    this._currentDepth = 0
+                    const dataset = this._getDataset(descriptor, rootData, i)
+                    const map = new Map<string, Descriptor>()
+                    const childs: Descriptor[] = []
+                    const clone = this._markAndClone(template, dataset, descriptor.uuid, map, childs)
+                    Descriptor.fixReferences(childs, map)
+                    this._cloneCollection.set(i, clone)
+                    observer.trigger('add', { self: clone.uuid, puid: descriptor.uuid })
+                }
+            }
+        }
+
+        observer.listen('add', this._onAdd)
+        observer.listen('remove', this._onRemove)
+        observer.listen('update', this._onUpdate)
+    }
+
+    free(descriptor: Descriptor) {
+        observer.unlisten('add', this._onAdd)
+        observer.unlisten('remove', this._onRemove)
+        observer.unlisten('update', this._onUpdate)
+        super.free(descriptor)
+    }
+}
+FragmentInterpreter.register(DynamicInterpreter)

package/output/engine/src/interpreter/FragmentInterpreter.ts

@@ -0,0 +1,34 @@
+import { FragmentActor } from "../actor";
+import { Descriptor } from "../descriptor";
+import { Interpreter } from "./Interpreter";
+
+class FragmentInterpreter extends Interpreter {
+    static type = Descriptor.type
+
+    protected createActor(descriptor: Descriptor) {
+        return new FragmentActor()
+    }
+
+    /**将节点挂载到场景 */
+    mount(descriptor: Descriptor, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
+        super.mount(descriptor, parentInterpreter, parentDescriptor)
+        const actor = this.getActor<FragmentActor>(descriptor)
+        actor.bind(parentDescriptor.uuid)
+    }
+
+    /**将节点从场景中卸载 */
+    unmount(descriptor: Descriptor, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
+        super.unmount(descriptor, parentInterpreter, parentDescriptor)
+    }
+
+    free(descriptor: Descriptor): void {
+        const actor = this.getActor<FragmentActor>(descriptor)
+        actor.unbind()
+        super.free(descriptor)
+    }
+}
+Interpreter.register(FragmentInterpreter)
+
+export {
+    FragmentInterpreter
+}

package/output/engine/src/interpreter/HTMLServiceInterpreter.ts

@@ -0,0 +1,47 @@
+import { Descriptor, HTMLServiceDescriptor } from "../descriptor"
+import { Interpreter, ServiceInterpreter } from "."
+import { HTMLActor, HTMLServiceActor } from "../actor"
+import { PickupObject } from "../graphics"
+
+class HTMLServiceInterpreter extends ServiceInterpreter {
+    static type = HTMLServiceDescriptor.type
+
+    protected createActor(descriptor: HTMLServiceDescriptor) {
+        const actor = new HTMLServiceActor(descriptor.uuid)
+        actor.DOM.addEventListener('pointerdown', e => e.stopPropagation())
+        return actor
+    }
+
+    update(descriptor: HTMLServiceDescriptor) {
+        super.update(descriptor)
+
+        const actor = this.getActor<HTMLServiceActor>(descriptor)
+        actor.update(descriptor)
+    }
+
+    mount(descriptor: HTMLServiceDescriptor, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
+        super.mount(descriptor, parentInterpreter, parentDescriptor)
+        const actor = this.getActor<HTMLServiceActor>(descriptor)
+
+        const parenActor = parentInterpreter.getActor<HTMLActor>(parentDescriptor)
+        parenActor.add(actor)
+    }
+
+    unmount(descriptor: HTMLServiceDescriptor, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
+        const actor = this.getActor<HTMLServiceActor>(descriptor)
+        actor.clearStyleClass(actor.DOM)
+        actor.cleanInteraction()
+
+        const parenActor = parentInterpreter.getActor<HTMLActor>(parentDescriptor)
+        parenActor.remove(actor)
+
+        super.unmount(descriptor, parentInterpreter, parentDescriptor)
+    }
+
+    pickup(descriptor: HTMLServiceDescriptor, result: PickupObject[]) {
+        result.push({ uuid: descriptor.uuid, generatedBy: descriptor.generatedBy })
+    }
+}
+ServiceInterpreter.register(HTMLServiceInterpreter)
+
+export { HTMLServiceInterpreter }