You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
582 lines
20 KiB
582 lines
20 KiB
import * as THREE from 'three'
|
|
import type Viewport from '@/core/engine/Viewport'
|
|
import type BaseRenderer from '@/core/base/BaseRenderer'
|
|
import { getRenderer } from './ModuleManager'
|
|
import { getClosestObject, getLineId, parseLineId } from '@/core/ModelUtils'
|
|
import { Vector2 } from 'three'
|
|
import { getFreezeDeep } from '@/utils/webutils.ts'
|
|
import type { LineLike, Object3DLike } from '@/types/ModelTypes.ts'
|
|
|
|
/**
|
|
* 实体管理器
|
|
* 缓存所有 数据(ItemJson)和他们的关系, 以及渲染对象 THREE.Object3D
|
|
* 数据更新的流程是:
|
|
* 1. 状态管理器 StateManager 发出数据被修改的请求, 这些请求通常只有 ItemJson 数据
|
|
* 2. 实体管理器 (EntityManager) 需要计算所有相关的点和线的变化. 在 endUpdate 时需要根据 center / in / out 关系, 计算出: 点的创建 / 点的更新 / 点的删除 / 线的创建 / 线的更新 / 线的删除
|
|
* 3. 通知对应的渲染器 (Renderer) 进行点和线的创建 / 更新 / 删除
|
|
*/
|
|
export default class EntityManager {
|
|
viewport: Viewport
|
|
|
|
// 所有数据点的实体
|
|
private readonly ___entityMap = new Map<string, ItemJson>()
|
|
|
|
// 关系索引
|
|
private readonly __relationIndex = new Map<string, Relation>()
|
|
|
|
// 所有 THREEJS "点"对象, 检索值是"点实体"的 id, 值是 THREE.Object3D 数组
|
|
private readonly __objectMap = new Map<string, Object3DLike>()
|
|
|
|
// 所有 THREEJS "可选中"对象, 检索值是"点实体"的 id, 值是 THREE.Object3D 数组
|
|
readonly _selectableObjects: THREE.Object3D[] = []
|
|
|
|
readonly _draggableObjects: THREE.Object3D[] = []
|
|
|
|
// 所有 THREEJS "线"对象, 检索值是"线实体"的 id, 取值方式是 {type}${startId}${endId}, 值是 THREE.Object3D 数组
|
|
private readonly __lineMap = new Map<string, LineLike>()
|
|
|
|
// 差量渲染器
|
|
private readonly diffRenderer = new Map<string, BaseRenderer>()
|
|
// 线差量记录
|
|
private readonly lineDiffs = {
|
|
create: new Map<string, LineDiffItem>(),
|
|
update: new Map<string, LineDiffItem>(),
|
|
delete: new Map<string, LineDiffItem>()
|
|
}
|
|
// 记录所有发生过变化的实体, 用于在 endEntityUpdate 时进行写回给 StateManager
|
|
private readonly writeBackEntities = new Set<string>()
|
|
isUpdating = false
|
|
|
|
getAllEntityForGrid() {
|
|
return Array.from(this.___entityMap.values())
|
|
}
|
|
|
|
getEntityMapForFindManager() {
|
|
return this.___entityMap
|
|
}
|
|
|
|
dispose() {
|
|
// 清理所有差量渲染器
|
|
for (const renderer of this.diffRenderer.values()) {
|
|
renderer.dispose()
|
|
}
|
|
this.diffRenderer.clear()
|
|
|
|
// 清理所有实体和关系索引
|
|
this.___entityMap.clear()
|
|
this.__relationIndex.clear()
|
|
this.__objectMap.clear()
|
|
this.__lineMap.clear()
|
|
this.writeBackEntities.clear()
|
|
}
|
|
|
|
/**
|
|
* 克隆需要回写的实体集合
|
|
*/
|
|
cloneWriteBackEntities(): Map<string, ItemJson> {
|
|
const result = new Map<string, ItemJson>()
|
|
for (const id of this.writeBackEntities) {
|
|
const entity = this.___entityMap.get(id)
|
|
if (!entity) continue
|
|
result.set(id, _.cloneDeep(entity))
|
|
}
|
|
console.log('需要回写', result.size, '行数据')
|
|
return result
|
|
}
|
|
|
|
init(viewport: Viewport) {
|
|
this.viewport = viewport
|
|
}
|
|
|
|
/**
|
|
* 批量更新开始
|
|
*/
|
|
beginEntityUpdate(): void {
|
|
this.isUpdating = true
|
|
this.viewport.beginViewUpdate()
|
|
this.writeBackEntities.clear()
|
|
this.diffRenderer.clear()
|
|
this.lineDiffs.create.clear()
|
|
this.lineDiffs.update.clear()
|
|
this.lineDiffs.delete.clear()
|
|
}
|
|
|
|
/**
|
|
* 创建或更新一个实体, 这个点的 center[] / in[] / out[] 关联的点, 可能都要对应进行关联
|
|
*/
|
|
createOrUpdateEntity(entity: ItemJson, option: EntityCudOption = {}): void {
|
|
// if (!entityRaw?.id) {
|
|
if (!entity?.id) {
|
|
throw new Error('Entity must have an id')
|
|
}
|
|
|
|
this.viewport.itemFindManager.addOrUpdate(entity)
|
|
|
|
// 改成非深拷贝, 直接使用原始数据, 因为 renderer 可能会修改这个数据, 后续也要能生效
|
|
// const entity = _.cloneDeep(entityRaw) as ItemJson
|
|
const originEntity = this.___entityMap.get(entity.id)
|
|
|
|
// 找到这个数据的渲染器
|
|
const renderer = this.getDiffRenderer(entity.t)
|
|
|
|
// 先判断坐标是否变化
|
|
const coordinateChanged = originEntity?.tf && entity?.tf && !_.isEqual(originEntity.tf[0], entity.tf[0])
|
|
this.___entityMap.set(entity.id, entity)
|
|
|
|
// 更新关系网
|
|
this.updateRelations(entity, originEntity)
|
|
|
|
if (coordinateChanged) {
|
|
this.writeBackEntities.add(entity.id)
|
|
// 点的坐标发生变化, 要通知所有关联线更新
|
|
const relation = this.__relationIndex.get(entity.id)
|
|
|
|
if (relation) {
|
|
for (const type of (['center', 'input', 'output'] as LinkType[])) {
|
|
const relatedIds = relation[type]
|
|
if (!relatedIds) continue
|
|
|
|
for (const relatedId of relatedIds) {
|
|
const lineId = getLineId(entity.id, relatedId, type)
|
|
console.log(`[update] ${entity.id} -> ${relatedId} [${type}] => ${lineId}`)
|
|
this.lineDiffs.update.set(lineId, { startId: entity.id, endId: relatedId, type })
|
|
|
|
this.writeBackEntities.add(relatedId)
|
|
|
|
// 如果是双向线（比如 center），也要反向加一次
|
|
if (type === 'center') {
|
|
this.lineDiffs.update.set(lineId, { startId: relatedId, endId: entity.id, type })
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (typeof originEntity === 'undefined') {
|
|
renderer.createPointForEntity(entity, option as RendererCudOption)
|
|
|
|
} else {
|
|
option.originEntity = _.cloneDeep(originEntity)
|
|
renderer.updatePointForEntity(entity, option as RendererCudOption)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 删除实体, 与这个点有关的所有线都要删除, 与这个点有关系的点,都要对应的 center[] / in[] / out[] 都要断绝关系
|
|
*/
|
|
deleteEntity(id: string, option: EntityCudOption = {}): void {
|
|
const entity = this.___entityMap.get(id)
|
|
if (!entity) return
|
|
|
|
this.viewport.itemFindManager.remove(id)
|
|
|
|
option.originEntity = _.cloneDeep(entity)
|
|
this.writeBackEntities.add(id)
|
|
|
|
// 先生成线差量，再清理关系
|
|
this.generateLineDiffsForDelete(id)
|
|
this.removeRelations(id) // 清理关系
|
|
this.___entityMap.delete(id) // 删除实体
|
|
|
|
this.getDiffRenderer(entity.t).deletePoint(id, option as RendererCudOption)
|
|
}
|
|
|
|
generateLineDiffsForDelete(id: string): void {
|
|
const relations = this.__relationIndex.get(id)
|
|
if (!relations) return
|
|
|
|
const removeLine = (relatedId: string, type: LinkType) => {
|
|
const lineId = getLineId(id, relatedId, type)
|
|
this.writeBackEntities.add(relatedId)
|
|
this.lineDiffs.delete.set(lineId, { startId: id, endId: relatedId, type })
|
|
}
|
|
|
|
relations.center.forEach(relatedId => removeLine(relatedId, 'center'))
|
|
relations.input.forEach(relatedId => removeLine(relatedId, 'in'))
|
|
relations.output.forEach(relatedId => removeLine(relatedId, 'out'))
|
|
}
|
|
|
|
/**
|
|
* 批量更新结束, 结束后会触发视窗的渲染
|
|
* 这个方法最重要的是进行连线逻辑的处理
|
|
* - 如果进行了添加, 那么这个点的 center[] / in[] / out[] 关联的点, 都要对应进行关联
|
|
* - 如果进行了删除, 与这个点有关的所有线都要删除, 与这个点有关系的点,都要对应的 center[] / in[] / out[] 都要断绝关系
|
|
* - 如果进行了更新, 如果改了颜色/位置, 则需要在UI上进行对应修改，如果改了关系，需要与关联的节点批量调整
|
|
* 将影响到的所有数据, 都变成一个修改集合, 统一调用对应单元类型渲染器(BaseRenderer)的 createPoint / deletePoint / updatePoint / createLine / updateLine / deleteLine 方法
|
|
*/
|
|
endEntityUpdate(): void {
|
|
for (const [itemTypeName, renderer] of this.diffRenderer.entries()) {
|
|
// "线"创建
|
|
for (const [lineId, lineDiffItem] of this.lineDiffs.create.entries()) {
|
|
const start = this.___entityMap.get(lineDiffItem.startId)
|
|
const end = this.___entityMap.get(lineDiffItem.endId)
|
|
|
|
// 添加存在性检查
|
|
if (!start || !end) {
|
|
system.showErrorDialog(`无法创建线 ${lineId}, 起点或终点不存在`)
|
|
continue
|
|
}
|
|
|
|
if (start.t !== itemTypeName) {
|
|
// 只通知起点对应的渲染器
|
|
continue
|
|
}
|
|
renderer.createLine(start, end, lineDiffItem.type)
|
|
}
|
|
|
|
// "线"更新
|
|
for (const [lineId, lineDiffItem] of this.lineDiffs.update.entries()) {
|
|
const start = this.___entityMap.get(lineDiffItem.startId)
|
|
const end = this.___entityMap.get(lineDiffItem.endId)
|
|
|
|
// 添加存在性检查
|
|
if (!start || !end) {
|
|
system.showErrorDialog(`无法更新线 ${lineId}, 起点或终点不存在`)
|
|
continue
|
|
}
|
|
|
|
if (start.t !== itemTypeName) {
|
|
// 只通知起点对应的渲染器
|
|
continue
|
|
}
|
|
renderer.updateLineForEntity(start, end, lineDiffItem.type)
|
|
}
|
|
|
|
// "线"删除
|
|
for (const [lineId, lineDiffItem] of this.lineDiffs.delete.entries()) {
|
|
const start = this.___entityMap.get(lineDiffItem.startId)
|
|
const end = this.___entityMap.get(lineDiffItem.endId)
|
|
|
|
if (!start || !end) {
|
|
// 即使实体不存在也要处理删除
|
|
renderer.deleteLine(
|
|
start || { id: lineDiffItem.startId, t: 'unknown' } as ItemJson,
|
|
end || { id: lineDiffItem.endId, t: 'unknown' } as ItemJson,
|
|
lineDiffItem.type)
|
|
continue
|
|
}
|
|
|
|
if (start.t !== itemTypeName) {
|
|
// 只通知起点对应的渲染器
|
|
continue
|
|
}
|
|
|
|
// 使用安全删除方法, 即使实体不存在也要处理删除
|
|
renderer.deleteLine(start, end, lineDiffItem.type)
|
|
}
|
|
|
|
renderer.endRendererUpdate()
|
|
}
|
|
|
|
// 将 lineDiffs 中新的关系网数据, 更新到实体点里
|
|
const needUpdateIds = new Set<string>()
|
|
for (const [lineId, lineDiffItem] of this.lineDiffs.create.entries()) {
|
|
needUpdateIds.add(lineDiffItem.startId)
|
|
needUpdateIds.add(lineDiffItem.endId)
|
|
}
|
|
for (const [lineId, lineDiffItem] of this.lineDiffs.update.entries()) {
|
|
needUpdateIds.add(lineDiffItem.startId)
|
|
needUpdateIds.add(lineDiffItem.endId)
|
|
}
|
|
for (const [lineId, lineDiffItem] of this.lineDiffs.delete.entries()) {
|
|
needUpdateIds.add(lineDiffItem.startId)
|
|
needUpdateIds.add(lineDiffItem.endId)
|
|
}
|
|
for (const id of needUpdateIds) {
|
|
const entity = this.___entityMap.get(id)
|
|
if (entity) {
|
|
entity.dt.center = Array.from(this.__relationIndex.get(id)?.center || [])
|
|
entity.dt.in = Array.from(this.__relationIndex.get(id)?.input || [])
|
|
entity.dt.out = Array.from(this.__relationIndex.get(id)?.output || [])
|
|
}
|
|
}
|
|
|
|
this.viewport.endViewUpdate()
|
|
this.isUpdating = false
|
|
}
|
|
|
|
/**
|
|
* 更新关系关系网, 计算出差值, 可以临时放在 diffRenderer 中, 等待 commitUpdate 时统一处理
|
|
*/
|
|
private updateRelations(entity: ItemJson, originEntity?: ItemJson): void {
|
|
const { id, dt } = entity
|
|
if (!id || !dt) return
|
|
|
|
const oldCenter = new Set(originEntity?.dt?.center || [])
|
|
const oldIn = new Set(originEntity?.dt?.in || [])
|
|
const oldOut = new Set(originEntity?.dt?.out || [])
|
|
|
|
const newCenter = new Set(dt.center || [])
|
|
const newIn = new Set(dt.in || [])
|
|
const newOut = new Set(dt.out || [])
|
|
|
|
// 更新正向关系
|
|
const relations = this.__relationIndex.get(id) || new Relation()
|
|
relations.center = newCenter
|
|
relations.input = newIn
|
|
relations.output = newOut
|
|
this.__relationIndex.set(id, relations)
|
|
|
|
// 更新反向关系
|
|
this.updateReverseRelations(id, oldCenter, newCenter, 'center')
|
|
this.updateReverseRelations(id, oldIn, newIn, 'out') // 入边的反向是出边
|
|
this.updateReverseRelations(id, oldOut, newOut, 'in') // 出边的反向是入边
|
|
|
|
// 更新线差量
|
|
this.calculateLineDiffs(id, oldCenter, newCenter, 'center')
|
|
this.calculateLineDiffs(id, oldIn, newIn, 'in')
|
|
this.calculateLineDiffs(id, oldOut, newOut, 'out')
|
|
}
|
|
|
|
private updateReverseRelations(id: string, oldIds: Set<string>, newIds: Set<string>, relationType: LinkType) {
|
|
// 确保关系索引存在
|
|
if (!this.__relationIndex.has(id)) {
|
|
this.__relationIndex.set(id, new Relation())
|
|
}
|
|
|
|
// 移除旧关系
|
|
for (const relatedId of oldIds) {
|
|
if (!newIds.has(relatedId)) {
|
|
const rev = this.__relationIndex.get(relatedId)
|
|
rev.delete(relationType, id)
|
|
this.writeBackEntities.add(relatedId)
|
|
}
|
|
}
|
|
|
|
// 添加新关系
|
|
for (const relatedId of newIds) {
|
|
if (!oldIds.has(relatedId)) {
|
|
let rev = this.__relationIndex.get(relatedId)
|
|
if (!rev) {
|
|
rev = new Relation()
|
|
this.__relationIndex.set(relatedId, rev)
|
|
}
|
|
rev.add(relationType, id)
|
|
this.writeBackEntities.add(relatedId)
|
|
}
|
|
}
|
|
}
|
|
|
|
private calculateLineDiffs(id: string, oldIds: Set<string>, newIds: Set<string>, lineType: LinkType) {
|
|
// 确保关系索引存在
|
|
if (!this.__relationIndex.has(id)) return
|
|
|
|
// 删除被移除的线
|
|
for (const relatedId of oldIds) {
|
|
if (!newIds.has(relatedId)) {
|
|
const lineId = getLineId(id, relatedId, lineType)
|
|
|
|
// 如果这条线已经在 update 列表中，则跳过 delete
|
|
if (this.lineDiffs.update.has(lineId)) continue
|
|
console.log(`[delete] ${id} -> ${relatedId} [${lineType}] => ${lineId}`)
|
|
this.lineDiffs.delete.set(lineId, { startId: id, endId: relatedId, type: lineType })
|
|
}
|
|
}
|
|
|
|
// 新增新增的线
|
|
for (const relatedId of newIds) {
|
|
if (!oldIds.has(relatedId)) {
|
|
const lineId = getLineId(id, relatedId, lineType)
|
|
|
|
// 如果这条线已经在 update 列表中，则跳过 create
|
|
if (this.lineDiffs.update.has(lineId)) continue
|
|
|
|
this.lineDiffs.create.set(lineId, { startId: id, endId: relatedId, type: lineType })
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* 删除关系关系网, 计算出差值, 可以临时放在 diffRenderer 中, 等待 commitUpdate 时统一处理
|
|
*/
|
|
private removeRelations(id: string): void {
|
|
const relations = this.__relationIndex.get(id)
|
|
if (!relations) return
|
|
|
|
relations.center.forEach(relatedId => {
|
|
const rev = this.__relationIndex.get(relatedId)
|
|
if (rev) rev.center.delete(id)
|
|
this.writeBackEntities.add(relatedId)
|
|
})
|
|
|
|
relations.input.forEach(relatedId => {
|
|
const rev = this.__relationIndex.get(relatedId)
|
|
if (rev) rev.output.delete(id)
|
|
this.writeBackEntities.add(relatedId)
|
|
})
|
|
|
|
relations.output.forEach(relatedId => {
|
|
const rev = this.__relationIndex.get(relatedId)
|
|
if (rev) rev.input.delete(id)
|
|
this.writeBackEntities.add(relatedId)
|
|
})
|
|
|
|
this.__relationIndex.delete(id)
|
|
}
|
|
|
|
private getDiffRenderer(type: string) {
|
|
let renderer = this.diffRenderer.get(type)
|
|
if (typeof renderer === 'undefined') {
|
|
renderer = getRenderer(type)
|
|
renderer.beginRendererUpdate(this.viewport)
|
|
this.diffRenderer.set(type, renderer)
|
|
}
|
|
return renderer
|
|
}
|
|
|
|
deleteEntityOnly(id: string) {
|
|
return this.___entityMap.delete(id)
|
|
}
|
|
|
|
findObjectById(id: string): Object3DLike | undefined {
|
|
return this.__objectMap.get(id)
|
|
}
|
|
|
|
replaceObject(id: string, newObject: Object3DLike) {
|
|
if (newObject.userData.entityId !== id) {
|
|
throw new Error(`New object must have userData.entityId set to ${id}`)
|
|
}
|
|
const originalObject = this.__objectMap.get(id)
|
|
|
|
_.remove(this._selectableObjects, obj => obj.userData?.entityId === id)
|
|
_.remove(this._draggableObjects, obj => obj.userData?.entityId === id)
|
|
|
|
this.__objectMap.set(id, newObject)
|
|
// 如果是可选中对象，添加到 _selectableObjects 中
|
|
if (newObject instanceof THREE.Object3D && newObject.userData.selectable !== false) {
|
|
this._selectableObjects.push(newObject)
|
|
}
|
|
if (newObject instanceof THREE.Object3D && newObject.userData.draggable) {
|
|
this._draggableObjects.push(newObject)
|
|
}
|
|
|
|
if (this.viewport.state.selectedEntityId === id) {
|
|
// 如果当前选中的对象被替换了，更新选中状态
|
|
this.viewport.selectManager.selectById(id)
|
|
}
|
|
if (_.includes(this.viewport.state.multiSelectedEntityIds, id)) {
|
|
// 如果当前多选的对象被替换了，更新多选状态
|
|
this.viewport.selectManager.multiSelectByIds(this.viewport.state.multiSelectedEntityIds)
|
|
}
|
|
}
|
|
|
|
appendObject(id: string, object: Object3DLike) {
|
|
this.__objectMap.set(id, object)
|
|
// 如果是可选中对象，添加到 _selectableObjects 中
|
|
if (object instanceof THREE.Object3D && object.userData.selectable !== false) {
|
|
this._selectableObjects.push(object)
|
|
}
|
|
if (object instanceof THREE.Object3D && object.userData.draggable) {
|
|
this._draggableObjects.push(object)
|
|
}
|
|
}
|
|
|
|
appendLineObject(id: string, lines: LineLike) {
|
|
this.__lineMap.set(id, lines)
|
|
}
|
|
|
|
findLineObjectById(lineId: string): LineLike | undefined {
|
|
return this.__lineMap.get(lineId)
|
|
}
|
|
|
|
deleteObjectsOnly(id: string) {
|
|
_.remove(this._selectableObjects, obj => obj.userData?.entityId === id)
|
|
_.remove(this._draggableObjects, obj => obj.userData?.entityId === id)
|
|
return this.__objectMap.delete(id)
|
|
}
|
|
|
|
deleteLineObjectOnly(id: string) {
|
|
// 删除线对象时，也需要从 _selectableObjects 中移除
|
|
_.remove(this._selectableObjects, obj => obj.userData?.entityId === id)
|
|
_.remove(this._draggableObjects, obj => obj.userData?.entityId === id)
|
|
return this.__lineMap.delete(id)
|
|
}
|
|
|
|
/**
|
|
* 根据 linkStartPointId 查找对应的 ItemJson
|
|
*/
|
|
findItemById(linkStartPointId: string): ItemJson | undefined {
|
|
if (!linkStartPointId) {
|
|
return
|
|
}
|
|
return this.___entityMap.get(linkStartPointId)
|
|
}
|
|
|
|
getObjectByCanvasMouse(event: MouseEvent): Object3DLike[] {
|
|
const _domElement = this.viewport.renderer.domElement
|
|
const rect = _domElement.getBoundingClientRect()
|
|
const _pointer = new Vector2()
|
|
_pointer.x = (event.clientX - rect.left) / rect.width * 2 - 1
|
|
_pointer.y = -(event.clientY - rect.top) / rect.height * 2 + 1
|
|
this.viewport.raycaster.setFromCamera(_pointer, this.viewport.camera)
|
|
const _intersections = this.viewport.raycaster.intersectObjects(this._selectableObjects, true)
|
|
|
|
if (!_intersections || _intersections.length === 0) {
|
|
return []
|
|
}
|
|
|
|
// 根据距离排序射线命中的对象集
|
|
return _.map(
|
|
_intersections.sort((a, b) => a.distance - b.distance),
|
|
r => getClosestObject(this.viewport, r.object, r.instanceId)
|
|
).filter((obj: Object3DLike) => obj?.userData && obj.userData.selectable !== false)
|
|
}
|
|
|
|
// /**
|
|
// * 获取指定范围内的所有对象
|
|
// */
|
|
// getObjectsInBox(startX: number, startZ: number, endX: number, endZ: number) {
|
|
// const box = new THREE.Box2(
|
|
// new THREE.Vector2(startX, startZ),
|
|
// new THREE.Vector2(endX, endZ)
|
|
// )
|
|
// const objectsInBox: Object3DLike[] = []
|
|
//
|
|
// for (const [id, obj] of this.__objectMap.entries()) {
|
|
// if (box.containsPoint(new Vector2(obj.position.x, obj.position.z))) {
|
|
// objectsInBox.push(obj)
|
|
// }
|
|
// }
|
|
//
|
|
// return objectsInBox
|
|
// }
|
|
}
|
|
|
|
interface LineDiffItem {
|
|
startId: string
|
|
endId: string
|
|
type: LinkType
|
|
}
|
|
|
|
|
|
/**
|
|
* 关系详情
|
|
*/
|
|
export class Relation {
|
|
center = new Set<string>()
|
|
input = new Set<string>()
|
|
output = new Set<string>()
|
|
|
|
add(type: LinkType, id: string) {
|
|
if (type === 'in')
|
|
return this.input.add(id)
|
|
else if (type === 'out')
|
|
return this.output.add(id)
|
|
else if (type === 'center')
|
|
return this.center.add(id)
|
|
else
|
|
throw new Error(`Unknown link type: ${type}`)
|
|
}
|
|
|
|
delete(type: LinkType, id: string) {
|
|
if (type === 'in')
|
|
return this.input.delete(id)
|
|
else if (type === 'out')
|
|
return this.output.delete(id)
|
|
else if (type === 'center')
|
|
return this.center.delete(id)
|
|
else
|
|
throw new Error(`Unknown link type: ${type}`)
|
|
}
|
|
}
|
|
|