@shijiu/jsview-vue 2.0.1021 → 2.0.1073

package/utils/JsViewEngineWidget/TemplateParser/CommonMetroTemplate.ts

@@ -0,0 +1,1424 @@
+import { Fence, GapInfo } from "./Fence";
+import { MetroTemplate, TemplateItem, MeasureInfo } from "./MetroTemplate"
+import { RangesModel, SingleRangeModel } from "../RangeModel";
+import { VERTICAL, HORIZONTAL, FocusMoveType } from "../WidgetCommon";
+
+const TAG = "CommonTemplateParser";
+
+/** neighbor related interface  */
+interface Edge {
+  position: number,
+  range: RangesModel,
+}
+
+interface EdgeInfo {
+  index: number,
+  edgeObj: {
+    leftEdge: Edge | null,
+    rightEdge: Edge | null,
+    topEdge: Edge | null,
+    bottomEdge: Edge | null,
+  }
+}
+
+/** get visible list related interface */
+interface VisibleSearchConfigCommon {
+  resultStartIdx: number,
+  resultEndIdx: number,
+  enableBackwardSearching: boolean,
+  enableForwardSearching: boolean,
+  checkingStartLinePos: number,
+  checkingEndLinePos: number,
+};
+
+interface VisibleSearchConfig {
+  searchDirect: number;
+  baseIdx: number;
+  checkingStartLineRanges: RangesModel;
+  startLineRangesFulled: boolean;
+  latestOverStartLineIdx: number;
+  checkingEndLineRanges: RangesModel;
+  endLineRangesFulled: boolean;
+  latestOverEndLineIdx: number;
+  endSearchingIndex: number;
+  firstStartLineBlockIdx: number;
+  firstEndLineBlockIdx: number;
+  searchToBorder: boolean;
+  common: VisibleSearchConfigCommon;
+};
+
+class CommonMetroTemplate extends MetroTemplate {
+  private _FenceStack: Array<Fence>;
+  private _FenceEdge: { StartX: number, StartY: number };
+  private _NotOccupiedEdgeList: Array<EdgeInfo>;
+
+  constructor(direction: Symbol, lineMax: number, pageSize: number,
+    layoutType: string, supportHistoryPath: boolean) {
+    super(direction, lineMax, pageSize, layoutType, supportHistoryPath);
+    this._FenceStack = [new Fence(0, 0, this.lineMax, 0)];
+    this._FenceEdge = { StartX: 0, StartY: 0 }; // 新的未占用边列表生成
+    this._NotOccupiedEdgeList = []; // 未占用边列表
+
+  }
+
+  public calculateNeighborWhenAddStop(): void {
+    // Update Last Fence Edge(更新最后一行的fence edge）
+    this._UpdateLastFenceEdge();
+    // Last fence edge to get neighbor
+    this._CalculateNeighborItem();
+    this._CalculateNeighborItem(true);
+    const templateList = this.templateList;
+    //处理找到的neighbor均是占位符的情况
+    for (let j = templateList.length - 1; j >= 0; j--) {
+      const item = templateList[j];
+      if (item.focusable) {
+        this._FindFocusableNeighbor("bottom", item);
+        this._FindFocusableNeighbor("top", item);
+        this._FindFocusableNeighbor("left", item);
+        this._FindFocusableNeighbor("right", item);
+      }
+    }
+  }
+
+  private _UpdateLastFenceEdge() {
+    const oldFence = this._FenceEdge;
+    const newMinFence = { StartX: -1, StartY: -1 };
+    // 查找最后一条FenceEdge
+    for (let i = 0; i < this._NotOccupiedEdgeList.length; i++) {
+      const crossItem = this._NotOccupiedEdgeList[i];
+      const crossEdgeObj = crossItem.edgeObj;
+      if (this.direction === VERTICAL) {
+        if (crossEdgeObj.bottomEdge !== null) {
+          if (crossEdgeObj.bottomEdge.position > oldFence.StartY) {
+            if (newMinFence.StartY === -1) {
+              newMinFence.StartY = crossEdgeObj.bottomEdge.position;
+            } else if (crossEdgeObj.bottomEdge.position < newMinFence.StartY) {
+              newMinFence.StartY = crossEdgeObj.bottomEdge.position;
+            }
+          }
+        }
+      } else {
+        if (crossEdgeObj.rightEdge !== null) {
+          if (crossEdgeObj.rightEdge.position > oldFence.StartX) {
+            if (newMinFence.StartX === -1) {
+              newMinFence.StartX = crossEdgeObj.rightEdge.position;
+            } else if (crossEdgeObj.rightEdge.position < newMinFence.StartX) {
+              newMinFence.StartX = crossEdgeObj.rightEdge.position;
+            }
+          }
+        }
+      }
+    }
+
+    this._FenceEdge = newMinFence;
+  }
+
+  private _CheckIdsHasFocusable(ids: Array<number>) {
+    const templateList = this.templateList;
+    let found = false;
+    for (let i = 0; i < ids.length; i++) {
+      const id = ids[i];
+      if (templateList[id].focusable) {
+        found = true;
+        break;
+      }
+    }
+    return found;
+  }
+
+
+  private _GetValidNeighborIndex(srcItemId: number, lastItemId: number, neighborDirection: string) {
+    const templateList = this.templateList;
+    let validId = -1;
+    const item = templateList[lastItemId];
+    const srcItem = templateList[srcItemId];
+    let firstIds: Array<number>;
+    let secondIds: Array<number>;
+
+    if (neighborDirection === "top") {
+      // 查找左侧邻居节点
+      secondIds = item.neighborIndexList.left;
+      firstIds = item.neighborIndexList.right;
+    } else {
+      // left, right
+      secondIds = item.neighborIndexList.right;
+      firstIds = item.neighborIndexList.left;
+    }
+
+    if (firstIds.length > 0) {
+      for (let i = 0; i < firstIds.length; i++) {
+        const id = firstIds[i];
+        const checkItem = templateList[id];
+        if (
+          checkItem.focusable &&
+          ((neighborDirection === "top" &&
+            checkItem.top + checkItem.height <= srcItem.top) ||
+            (neighborDirection === "bottom" &&
+              checkItem.top >= srcItem.top + srcItem.height))
+        ) {
+          // 并且在srcItemId之上或之下
+          validId = id;
+          break;
+        }
+      }
+    }
+    if (validId === -1) {
+      if (secondIds.length > 0) {
+        for (let i = 0; i < secondIds.length; i++) {
+          const id = secondIds[i];
+          const checkItem = templateList[id];
+          if (
+            checkItem.focusable &&
+            ((neighborDirection === "top" &&
+              checkItem.top + checkItem.height <= srcItem.top) ||
+              (neighborDirection === "bottom" &&
+                checkItem.top >= srcItem.top + srcItem.height))
+          ) {
+            // 并且在srcItemId之上或之下
+            validId = id;
+            break;
+          }
+        }
+      }
+    }
+    return validId;
+  }
+
+  private _FindFocusableNeighbor(direction: string, item: TemplateItem) {
+    if (
+      item.neighborIndexList[direction].length > 0 &&
+      !this._CheckIdsHasFocusable(item.neighborIndexList[direction])
+    ) {
+      const lastItemId =
+        item.neighborIndexList[direction][
+        item.neighborIndexList[direction].length - 1
+        ];
+      const idx = this._GetValidNeighborIndex(item.id, lastItemId, direction); // 查找其左右邻居
+      if (idx !== -1) {
+        item.neighborIndexList[direction] = []; // 清除无效项
+        item.neighborIndexList[direction].push(idx);
+      }
+    }
+  }
+
+  public addItem(itemObj: MeasureInfo): TemplateItem {
+    const templateItem = MetroTemplate.getTemplateItem(itemObj);
+    // Layout template items
+    const fenceStack = this._FenceStack;
+    const itemWidth = templateItem.width;
+    const itemHeight = templateItem.height;
+    // Add view to contents view layer
+    let xPos: number;
+    let yPos: number;
+    let xWidth: number;
+    let yWidth: number;
+    let itemKeyPos = 0;
+    let itemSecondPos = 0;
+
+    let itemKeyWidth = 0;
+    let itemSecondWidth = 0;
+    let itemKeyMargin = 0;
+    let itemSecondMargin = 0;
+    if (this.layoutType === "relative") {
+      if (this.direction === VERTICAL) {
+        itemKeyWidth = itemWidth;
+        itemSecondWidth = itemHeight;
+        itemKeyMargin = templateItem.marginRight;
+        itemSecondMargin = templateItem.marginBottom;
+      } else {
+        itemKeyWidth = itemHeight;
+        itemSecondWidth = itemWidth;
+        itemKeyMargin = templateItem.marginBottom;
+        itemSecondMargin = templateItem.marginRight;
+      }
+      // Find capability fence in stack
+      let topFence: Fence | null = null;
+      let gapInfo: GapInfo | null = null;
+      while (fenceStack.length > 0) {
+        const checkingFence = fenceStack[fenceStack.length - 1];
+        gapInfo = checkingFence.HasGapFor(itemKeyWidth + itemKeyMargin);
+        if (gapInfo !== null) {
+          topFence = checkingFence;
+          break;
+        }
+        fenceStack.pop();
+      }
+
+      // Layout the item in top fence
+      if (gapInfo !== null && topFence != null) {
+        itemKeyPos = gapInfo.GapStart;
+        itemSecondPos = topFence.AheadOffset;
+      } else {
+        throw new Error(
+          `${TAG} item size ${itemWidth}x${itemHeight} is greater than widget line max ${this.lineMax}`
+        );
+        // console.error(TAG, "ERROR: coding error, header full gap fence lost");
+      }
+
+      if (this.direction === VERTICAL) {
+        xPos = itemKeyPos;
+        yPos = itemSecondPos;
+        xWidth = itemKeyWidth;
+        yWidth = itemSecondWidth;
+      } else {
+        xPos = itemSecondPos;
+        yPos = itemKeyPos;
+        xWidth = itemSecondWidth;
+        yWidth = itemKeyWidth;
+      }
+    } else {
+      xPos = templateItem.left;
+      yPos = templateItem.top;
+      xWidth = itemWidth;
+      yWidth = itemHeight;
+    }
+
+    templateItem.left = xPos;
+    templateItem.top = yPos;
+    templateItem.centerXPos = Math.floor(xPos + xWidth / 2) - 1;
+    templateItem.centerYPos = Math.floor(yPos + yWidth / 2) - 1;
+    //分页相关的计算
+    let curPageNumber = 0;
+    let curPageHeadIndex = 0;
+    if (this.templateList.length > 0) {
+      const lastItem = this.templateList[this.templateList.length - 1];
+      curPageNumber = lastItem.pageNumber;
+      curPageHeadIndex = lastItem.pageHeadIndex;
+      let positionKey = "left";
+      let sizeKey = "width";
+      if (this.direction === VERTICAL) {
+        positionKey = "top";
+        sizeKey = "height";
+      }
+      const curPageStart =
+        this.templateList[curPageHeadIndex][positionKey];
+      if (
+        templateItem[positionKey] + templateItem[sizeKey] >
+        curPageStart + this.pageSize
+      ) {
+        //新的页
+        curPageNumber++;
+        curPageHeadIndex = this.templateList.length;
+      }
+    }
+
+    templateItem.pageNumber = curPageNumber;
+    templateItem.pageHeadIndex = curPageHeadIndex;
+    this.addTemplateItem(templateItem);
+    // 计算相邻项
+    this._TryCalculateNeighborItem(
+      this.templateList.length - 1,
+      templateItem.left,
+      templateItem.top,
+      templateItem.width + templateItem.marginRight,
+      templateItem.height + templateItem.marginBottom
+    );
+
+    const itemSecondEndPos =
+      itemSecondPos + itemSecondWidth + itemSecondMargin - 1;
+
+    // Ensure header fence
+    if (fenceStack[0].AheadOffset <= itemSecondEndPos) {
+      // Need new header fence
+      fenceStack.splice(
+        0,
+        0,
+        new Fence(0, 0, this.lineMax, itemSecondEndPos + 1)
+      );
+    }
+
+    // Mark gap used in fence stack
+    let endFenceExisted = false;
+    let farAwayEndFenceExisted = false;
+    let oneAheadLastFenceIdx = -1;
+    for (let fenceIdx = fenceStack.length - 1; fenceIdx >= 0; fenceIdx--) {
+      if (fenceStack[fenceIdx].AheadOffset <= itemSecondEndPos) {
+        if (fenceStack[fenceIdx].AheadOffset === itemSecondEndPos)
+          endFenceExisted = true;
+        const leftGaps = fenceStack[fenceIdx].MarkGapUsed(
+          itemKeyPos,
+          itemKeyWidth + itemKeyMargin
+        );
+        if (leftGaps === 0) {
+          // remove fence
+          fenceStack.splice(fenceIdx, 1);
+        }
+      } else {
+        if (fenceStack[fenceIdx].AheadOffset === itemSecondEndPos + 1)
+          farAwayEndFenceExisted = true;
+        oneAheadLastFenceIdx = fenceIdx;
+        break;
+      }
+    }
+
+    const fenceAheadOffset = itemSecondEndPos;
+    // Create fences
+    if (!endFenceExisted) {
+      // Build fence edge which close to the beginning
+      if (oneAheadLastFenceIdx + 1 <= fenceStack.length - 1) {
+        const fence =
+          fenceStack[oneAheadLastFenceIdx + 1].Fork(fenceAheadOffset);
+        fenceStack.splice(oneAheadLastFenceIdx + 1, 0, fence);
+      }
+    }
+    if (!farAwayEndFenceExisted) {
+      // Build fence edge which far away from the beginning
+      if (oneAheadLastFenceIdx > 0) {
+        const fence = fenceStack[oneAheadLastFenceIdx].Fork(
+          fenceAheadOffset + 1
+        );
+        fenceStack.splice(oneAheadLastFenceIdx + 1, 0, fence);
+      }
+    }
+    return templateItem;
+  }
+
+  /** get next item functions */
+  public getNextItem(baseId: number, vOffset: number,
+    hOffset: number, moveType: number): TemplateItem | null {
+    if (vOffset === 0 && hOffset === 0)
+      console.log("GetNextItem(): offset is 0");
+    // Forge.ThrowError("GetNextItem(): offset is 0");
+
+    if (vOffset !== 0 && hOffset !== 0) {
+      console.log(
+        "GetNextItem(): not support change vertical and horizontal at the same time"
+      );
+      // Forge.ThrowError("GetNextItem(): not support change vertical and horizontal and the same time");
+    }
+
+    const itemIndex = this.id2Index(baseId);
+    const offset = vOffset !== 0 ? vOffset : hOffset;
+    let nextTemplateItem = this.getNextItemInner(
+      itemIndex,
+      offset,
+      vOffset !== 0
+    );
+    const isVertical = this.direction === VERTICAL;
+
+    if (nextTemplateItem === null) {
+      // 在次方向的焦点移动才会loop
+      if (
+        isVertical &&
+        moveType & FocusMoveType.ROW_LOOP &&
+        hOffset != 0
+      ) {
+        nextTemplateItem = this._GetNextLoopItem(
+          itemIndex,
+          hOffset,
+          isVertical
+        );
+      } else if (
+        !isVertical &&
+        moveType & FocusMoveType.COLUMN_LOOP &&
+        vOffset != 0
+      ) {
+        nextTemplateItem = this._GetNextLoopItem(
+          itemIndex,
+          vOffset,
+          isVertical
+        );
+      }
+    }
+
+    if (nextTemplateItem === null) {
+      // 临近行的焦点移动
+      if (
+        vOffset != 0 &&
+        moveType & FocusMoveType.ROW_FIND_NEAR
+      ) {
+        nextTemplateItem = this._GetNearLineItem(itemIndex, vOffset, true);
+      } else if (
+        hOffset != 0 &&
+        moveType & FocusMoveType.COLUMN_FIND_NEAR
+      ) {
+        nextTemplateItem = this._GetNearLineItem(itemIndex, hOffset, false);
+      }
+    }
+
+    return nextTemplateItem;
+  }
+
+
+  private getNextItemInner(index: number, offset: number, vertical: boolean) {
+    const templateList = this.templateList;
+    const baseItem = templateList[index];
+    let checkAnchor = -1;
+    if (baseItem.findNextAnchor) {
+      //有自定义的 anchor
+      // TODO 优化
+      if (vertical) {
+        if (offset > 0) {
+          if (baseItem.findNextAnchor.bottom) {
+            checkAnchor =
+              baseItem.left +
+              baseItem.findNextAnchor.bottom *
+              (baseItem.width + baseItem.marginRight);
+          }
+        } else {
+          if (baseItem.findNextAnchor.top) {
+            checkAnchor =
+              baseItem.left +
+              baseItem.findNextAnchor.top *
+              (baseItem.width + baseItem.marginRight);
+          }
+        }
+      } else {
+        if (offset > 0) {
+          if (baseItem.findNextAnchor.right) {
+            checkAnchor =
+              baseItem.top +
+              baseItem.findNextAnchor.right *
+              (baseItem.height + baseItem.marginBottom);
+          }
+        } else {
+          if (baseItem.findNextAnchor.left) {
+            checkAnchor =
+              baseItem.top +
+              baseItem.findNextAnchor.left *
+              (baseItem.height + baseItem.marginBottom);
+          }
+        }
+      }
+    }
+    if (checkAnchor < 0) {
+      checkAnchor = vertical ? baseItem.centerXPos : baseItem.centerYPos;
+    }
+    const posKey = vertical ? "left" : "top";
+    const sizeKey = vertical ? "width" : "height";
+    let direction = vertical ? "top" : "left";
+    let pathHistoryDirection = vertical ? "bottom" : "right";
+    // Normalize offset
+    if (offset > 0) {
+      pathHistoryDirection = vertical ? "top" : "left";
+      direction = vertical ? "bottom" : "right";
+    }
+    const notRecordHistoryDirection = vertical ? "bottom" : "right";
+    const notRecordHistoryOrient = vertical ? HORIZONTAL : VERTICAL;
+    let lastItemIndex = templateList.length - 1;
+    const orientType = this.direction;
+    // 查找有效的最后项
+    for (let i = templateList.length - 1; i >= 0; i--) {
+      const lastItem = templateList[i];
+      if (lastItem.focusable) {
+        lastItemIndex = i;
+        break;
+      }
+    }
+    let found = false;
+    let nextIndex = -1;
+    let pathHistoryIndex = -1;
+    if (this.supportHistoryPath && !baseItem.findNextAnchor) {
+      pathHistoryIndex = templateList[index].pathHistory[direction];
+    }
+    if (pathHistoryIndex < 0) {
+      // 无历史路径
+      // 获得邻近点列表
+      let neighborList = templateList[index].neighborIndexList[direction];
+      if (templateList[index].tmpNeighborIndexList[direction].length > 0) {
+        neighborList = neighborList.concat(
+          templateList[index].tmpNeighborIndexList[direction]
+        );
+      }
+      if (neighborList.length === 1) {
+        nextIndex = neighborList[0];
+        if (
+          lastItemIndex !== index ||
+          direction !== notRecordHistoryDirection ||
+          orientType !== notRecordHistoryOrient
+        ) {
+          // horizontal lastItemIndex bottom 不记历史路径
+          templateList[index].pathHistory[direction] = nextIndex; // 更新历史路径
+          templateList[nextIndex].pathHistory[pathHistoryDirection] = index; // 更新历史路径
+        }
+        found = true;
+      } else {
+        for (let i = 0; i < neighborList.length; i++) {
+          nextIndex = neighborList[i];
+          const checkingItem = templateList[nextIndex];
+          if (
+            checkAnchor <=
+            checkingItem[posKey] + checkingItem[sizeKey] - 1 &&
+            checkAnchor >= checkingItem[posKey]
+          ) {
+            if (
+              lastItemIndex !== index ||
+              direction !== notRecordHistoryDirection ||
+              orientType !== notRecordHistoryOrient
+            ) {
+              // horizontal lastItemIndex bottom 不记历史路径
+              templateList[index].pathHistory[direction] = nextIndex; // 更新历史路径
+              templateList[nextIndex].pathHistory[pathHistoryDirection] =
+                index; // 更新历史路径
+            }
+            found = true;
+            break;
+          }
+        }
+        // 若未找到中间位置的项目
+        // 若找到了项目，但是该项为非 focusable
+        // 则使用neighbor list中focusable项
+        if (!found || !templateList[nextIndex].focusable) {
+          for (let i = 0; i < neighborList.length; i++) {
+            const neighborIndex = neighborList[i];
+            const checkingItem = templateList[neighborIndex];
+            if (checkingItem.focusable) {
+              if (
+                lastItemIndex !== index ||
+                direction !== notRecordHistoryDirection ||
+                orientType !== notRecordHistoryOrient
+              ) {
+                // horizontal lastItemIndex bottom 不记历史路径
+                templateList[index].pathHistory[direction] = nextIndex; // 更新历史路径
+                templateList[nextIndex].pathHistory[pathHistoryDirection] =
+                  index; // 更新历史路径
+              }
+              nextIndex = neighborIndex;
+              found = true;
+              break;
+            }
+          }
+        }
+      }
+    } else {
+      nextIndex = pathHistoryIndex;
+      if (
+        lastItemIndex !== index ||
+        direction !== notRecordHistoryDirection ||
+        orientType !== notRecordHistoryOrient
+      ) {
+        // horizontal lastItemIndex bottom 不记历史路径
+        templateList[nextIndex].pathHistory[pathHistoryDirection] = index; // 更新历史路径
+      }
+      found = true;
+    }
+
+    if (found) {
+      if (!templateList[nextIndex].focusable) {
+        // 如果是占位符，则查找占位符的下一个
+        return this.getNextItemInner(nextIndex, offset, vertical);
+      }
+      return templateList[nextIndex];
+    }
+    return null;
+  }
+
+  private _GetItemDistance(item1: TemplateItem, item2: TemplateItem) {
+    return (
+      Math.pow(item1.centerXPos - item2.centerXPos, 2) +
+      Math.pow(item1.centerYPos - item2.centerYPos, 2)
+    );
+  }
+
+  private _GetTotalNeighbor(index: number, direction: string) {
+    const item = this.templateList[index];
+    return item.neighborIndexList[direction].concat(
+      item.tmpNeighborIndexList[direction]
+    );
+  }
+
+  private _GetNearestItem(targetItemIndex: number, itemIndexList: Array<number>) {
+    let nearestIndex = -1,
+      minDistance = Number.POSITIVE_INFINITY;
+    let targetItem = this.templateList[targetItemIndex];
+    for (let i of itemIndexList) {
+      const d = this._GetItemDistance(this.templateList[i], targetItem);
+      if (d < minDistance) {
+        nearestIndex = i;
+        minDistance = d;
+      }
+    }
+    return nearestIndex;
+  }
+
+  private _GetNextLoopItem(index: number, offset: number, isVertical: boolean) {
+    const templateList = this.templateList;
+    const baseItem = templateList[index];
+    let searchDirection = isVertical ? "right" : "bottom";
+    let startDirection = isVertical ? "top" : "left";
+    if (offset > 0) {
+      searchDirection = isVertical ? "left" : "top";
+      startDirection = isVertical ? "bottom" : "right";
+    }
+    let targetIndex = -1;
+    let focusableTarget = -1;
+    let startIndex = -1;
+    let neighborList = [];
+    //寻找下一列的起始item
+    neighborList = this._GetTotalNeighbor(index, searchDirection);
+    while (startIndex < 0 && neighborList.length > 0) {
+      for (let i of neighborList) {
+        if (this._GetTotalNeighbor(i, startDirection).length > 0) {
+          startIndex = i;
+          break;
+        } else {
+          //TODO 是否要用递归
+          neighborList = this._GetTotalNeighbor(i, searchDirection);
+        }
+      }
+    }
+    if (startIndex >= 0) {
+      neighborList = this._GetTotalNeighbor(startIndex, startDirection);
+
+      //寻找最近的neighbor
+      let nearestIndex = -1,
+        minDistance = Number.POSITIVE_INFINITY;
+      for (let i of neighborList) {
+        const d = this._GetItemDistance(templateList[i], baseItem);
+        if (d < minDistance) {
+          nearestIndex = i;
+          minDistance = d;
+        }
+      }
+
+      neighborList = this._GetTotalNeighbor(nearestIndex, searchDirection);
+      while (neighborList.length > 0) {
+        targetIndex = this._GetNearestItem(nearestIndex, neighborList);
+        if (templateList[targetIndex].focusable) {
+          focusableTarget = targetIndex;
+        }
+        neighborList = this._GetTotalNeighbor(targetIndex, searchDirection);
+      }
+      if (focusableTarget >= 0) {
+        return templateList[focusableTarget];
+      } else if (targetIndex >= 0) {
+        return this._GetNextLoopItem(targetIndex, offset, isVertical);
+      }
+    }
+    return null;
+  }
+
+  //获取临近行的item
+  private _GetNearLineItem(index: number, offset: number, isVertical: boolean) {
+    const templateList = this.templateList;
+    let searchDirection = isVertical ? "right" : "bottom";
+    let startDirection = isVertical ? "top" : "left";
+    if (offset > 0) {
+      searchDirection = isVertical ? "left" : "top";
+      startDirection = isVertical ? "bottom" : "right";
+    }
+    let startIndex = -1;
+    let neighborList = [];
+    //寻找下一列的起始item
+    neighborList = this._GetTotalNeighbor(index, searchDirection);
+    while (startIndex < 0 && neighborList.length > 0) {
+      for (let i of neighborList) {
+        const n = this._GetTotalNeighbor(i, startDirection);
+        if (n.length > 0) {
+          return templateList[this._GetNearestItem(index, n)];
+        } else {
+          //TODO 是否要用递归
+          neighborList = this._GetTotalNeighbor(i, searchDirection);
+        }
+      }
+    }
+    return null;
+  }
+
+  public updateItemSize(index: number, newSize: { width: number, height: number }): void {
+    console.error(TAG, "updateItemSize is not supported.");
+  }
+
+  /** get visible item list functions */
+  public getVisibleItemList(
+    visibleStart: number,
+    visibleEnd: number,
+    baseId: number): [number, number] {
+    if (visibleStart > visibleEnd) {
+      // No visible item
+      return [-1, -1];
+    }
+    //取整以避免starline和endline找不到骑线的item的bug
+    visibleStart = Math.round(visibleStart);
+    visibleEnd = Math.round(visibleEnd);
+    let searchBaseItemIdx = this.id2Index(baseId);
+    if (typeof searchBaseItemIdx === "undefined") searchBaseItemIdx = 0;
+    const commonData: VisibleSearchConfigCommon = {
+      resultStartIdx: -1,
+      resultEndIdx: -1,
+      enableBackwardSearching: true,
+      enableForwardSearching: true,
+      checkingStartLinePos: visibleStart,
+      checkingEndLinePos: visibleEnd,
+    };
+    const backwardConfigure: VisibleSearchConfig = {
+      searchDirect: -1,
+      baseIdx: searchBaseItemIdx,
+      checkingStartLineRanges: new RangesModel(0, 0),
+      startLineRangesFulled: false,
+      latestOverStartLineIdx: -1,
+      checkingEndLineRanges: new RangesModel(0, 0),
+      endLineRangesFulled: false,
+      latestOverEndLineIdx: -1,
+      endSearchingIndex: 0,
+      firstStartLineBlockIdx: -1,
+      firstEndLineBlockIdx: -1,
+      searchToBorder: false,
+      common: commonData,
+    };
+    const forwardConfigure: VisibleSearchConfig = {
+      searchDirect: 1,
+      baseIdx: searchBaseItemIdx,
+      checkingStartLineRanges: new RangesModel(0, 0),
+      startLineRangesFulled: false,
+      latestOverStartLineIdx: -1,
+      checkingEndLineRanges: new RangesModel(0, 0),
+      endLineRangesFulled: false,
+      latestOverEndLineIdx: -1,
+      endSearchingIndex: this.templateList.length - 1,
+      firstStartLineBlockIdx: -1,
+      firstEndLineBlockIdx: -1,
+      searchToBorder: false,
+      common: commonData,
+    };
+
+    const isTemplateVertical = this.direction === VERTICAL;
+    let offset = 0;
+    while (
+      commonData.enableBackwardSearching ||
+      commonData.enableForwardSearching
+    ) {
+      if (commonData.enableBackwardSearching) {
+        this._DoSearching(backwardConfigure, -offset, isTemplateVertical);
+      }
+
+      if (commonData.enableForwardSearching) {
+        this._DoSearching(forwardConfigure, offset, isTemplateVertical);
+      }
+      offset++;
+    }
+    // console.log(
+    //   "GetVisibleItemList [" +
+    //     JSON.stringify(commonData) +
+    //     ", " +
+    //     JSON.stringify(backwardConfigure) +
+    //     ", " +
+    //     JSON.stringify(forwardConfigure) +
+    //     "]"
+    // );
+
+    if (commonData.resultStartIdx < 0) {
+      // When start index not found
+      // Use just over start line block as start idx
+      if (
+        backwardConfigure.latestOverStartLineIdx >= 0 &&
+        backwardConfigure.firstStartLineBlockIdx >= 0
+      )
+        commonData.resultStartIdx = backwardConfigure.latestOverStartLineIdx;
+      else if (forwardConfigure.firstStartLineBlockIdx >= 0)
+        commonData.resultStartIdx = forwardConfigure.firstStartLineBlockIdx;
+    }
+
+    if (commonData.resultEndIdx < 0) {
+      // When end index not found
+      // Use just over end line block as end idx
+      if (
+        forwardConfigure.latestOverEndLineIdx >= 0 &&
+        forwardConfigure.firstEndLineBlockIdx >= 0
+      )
+        commonData.resultEndIdx = forwardConfigure.latestOverEndLineIdx;
+      else if (backwardConfigure.firstEndLineBlockIdx >= 0)
+        commonData.resultEndIdx = backwardConfigure.firstEndLineBlockIdx;
+    }
+    // Recheck if whole contents inside the range
+    if (commonData.resultStartIdx < 0 && commonData.resultEndIdx < 0) {
+      // Check if whole contents inside the range
+      const firstItem = this.templateList[0];
+      const firstSecondPos = isTemplateVertical
+        ? firstItem.top
+        : firstItem.left;
+      const lastItem = this.templateList[this.templateList.length - 1];
+      const lastSecondPos = isTemplateVertical
+        ? lastItem.top
+        : lastItem.left;
+      const lastSecondWidth = isTemplateVertical
+        ? lastItem.height
+        : lastItem.width;
+      if (
+        firstSecondPos > visibleStart &&
+        lastSecondPos + lastSecondWidth < visibleEnd
+      ) {
+        commonData.resultStartIdx = 0;
+        commonData.resultEndIdx = this.templateList.length - 1;
+      }
+    }
+    let ret: [number, number] = [-1, -1];
+    if (commonData.resultStartIdx >= 0 || commonData.resultEndIdx >= 0) {
+      const startIdx =
+        commonData.resultStartIdx >= 0 ? commonData.resultStartIdx : 0;
+      const endIdx =
+        commonData.resultEndIdx >= 0
+          ? commonData.resultEndIdx
+          : this.templateList.length - 1;
+      ret = [startIdx, endIdx];
+    }
+    return ret;
+  }
+
+  private _DoSearching(configures: VisibleSearchConfig, offset: number, beVerticalTemplate: boolean) {
+    const checkItem = this.templateList[configures.baseIdx + offset];
+    const keyPos = beVerticalTemplate ? checkItem.left : checkItem.top;
+    const keyWidth = beVerticalTemplate
+      ? checkItem.width + checkItem.marginRight
+      : checkItem.height + checkItem.marginBottom;
+    const keyStart = Math.round(keyPos);
+    const keyEnd = Math.round(keyPos + keyWidth - 1);
+    const secondPos = beVerticalTemplate ? checkItem.top : checkItem.left;
+    const secondWidth = beVerticalTemplate
+      ? checkItem.height + checkItem.marginBottom
+      : checkItem.width + checkItem.marginRight;
+    const secondStart = Math.round(secondPos);
+    const secondEnd = Math.round(secondPos + secondWidth - 1);
+    // console.log(
+    //   "idx=" +
+    //     (configures.baseIdx + offset) +
+    //     " pos=" +
+    //     secondPos +
+    //     " posend=" +
+    //     (secondPos + secondWidth - 1) +
+    //     " linePos=" +
+    //     configures.common.checkingStartLinePos
+    // );
+
+    if (
+      configures.common.resultStartIdx < 0 &&
+      !configures.startLineRangesFulled
+    ) {
+      let isRangeChanged = false;
+      if (
+        secondStart <= configures.common.checkingStartLinePos &&
+        secondEnd >= configures.common.checkingStartLinePos
+      ) {
+        // Overlap the visbible start line
+        configures.latestOverStartLineIdx = configures.baseIdx + offset;
+        if (configures.firstStartLineBlockIdx < 0)
+          configures.firstStartLineBlockIdx = configures.baseIdx + offset;
+        configures.checkingStartLineRanges.Merge(
+          new SingleRangeModel(keyStart, keyEnd)
+        );
+        isRangeChanged = true;
+      } else if (
+        configures.searchDirect < 0 &&
+        secondEnd <= configures.common.checkingStartLinePos
+      ) {
+        // above the visible start line
+        configures.checkingStartLineRanges.Merge(
+          new SingleRangeModel(keyStart, keyEnd)
+        );
+        isRangeChanged = true;
+      }
+    }
+    // console.log(
+    //   "idx=" +
+    //     (configures.baseIdx + offset) +
+    //     " pos=" +
+    //     secondPos +
+    //     " posend=" +
+    //     (secondPos + secondWidth - 1) +
+    //     " linePos=" +
+    //     configures.common.checkingEndLinePos
+    // );
+    if (configures.common.resultEndIdx < 0 && !configures.endLineRangesFulled) {
+      let isRangeChanged = false;
+      if (
+        secondStart <= configures.common.checkingEndLinePos &&
+        secondEnd >= configures.common.checkingEndLinePos
+      ) {
+        // Overlap the visbible end line
+        configures.latestOverEndLineIdx = configures.baseIdx + offset;
+        if (configures.firstEndLineBlockIdx < 0)
+          configures.firstEndLineBlockIdx = configures.baseIdx + offset;
+        configures.checkingEndLineRanges.Merge(
+          new SingleRangeModel(keyStart, keyEnd)
+        );
+        isRangeChanged = true;
+      } else if (
+        configures.searchDirect > 0 &&
+        secondStart >= configures.common.checkingEndLinePos
+      ) {
+        // below the visible end line
+        configures.checkingEndLineRanges.Merge(
+          new SingleRangeModel(keyStart, keyEnd)
+        );
+        isRangeChanged = true;
+      }
+    }
+    if (configures.baseIdx + offset === configures.endSearchingIndex) {
+      if (configures.searchDirect > 0) {
+        configures.common.enableForwardSearching = false;
+      } else {
+        configures.common.enableBackwardSearching = false;
+      }
+      configures.searchToBorder = true;
+    }
+  }
+
+  /** neighbor calculate functions */
+  private _TryCalculateNeighborItem(index: number, xPos: number, yPos: number, width: number, height: number) {
+    const curNotOccupiedEdge: EdgeInfo = {
+      index,
+      edgeObj: {
+        leftEdge: {
+          position: xPos,
+          range: new RangesModel(yPos, yPos + height - 1),
+        },
+        rightEdge: {
+          position: xPos + width,
+          range: new RangesModel(yPos, yPos + height - 1),
+        },
+        topEdge: {
+          position: yPos,
+          range: new RangesModel(xPos, xPos + width - 1),
+        },
+        bottomEdge: {
+          position: yPos + height,
+          range: new RangesModel(xPos, xPos + width - 1),
+        },
+      },
+    };
+    // 边界处理，重置leftEdge和topEdge；
+    if (xPos === 0) {
+      curNotOccupiedEdge.edgeObj.leftEdge = null;
+    }
+    if (yPos === 0) {
+      curNotOccupiedEdge.edgeObj.topEdge = null;
+    }
+    let newFance = false;
+    // 边界处理，重置bootomEdge和rightEdge
+    const widthMax = this.lineMax;
+    let newFenceEdgeStart_x = this._FenceEdge.StartX;
+    let newFenceEdgeStart_y = this._FenceEdge.StartY;
+    if (this.direction === VERTICAL) {
+      if (xPos + width === widthMax) {
+        curNotOccupiedEdge.edgeObj.rightEdge = null;
+      }
+      // 判断FenceEdge，是否产生新的fence
+      if (yPos > this._FenceEdge.StartY) {
+        // 产生新的Fence
+        newFance = true;
+        newFenceEdgeStart_y = yPos;
+      }
+    } else {
+      if (yPos + height === widthMax) {
+        curNotOccupiedEdge.edgeObj.bottomEdge = null;
+      }
+      // 判断FenceEdge，是否产生新的fence
+      if (xPos > this._FenceEdge.StartX) {
+        // 产生新的Fence
+        newFance = true;
+        newFenceEdgeStart_x = xPos;
+      }
+    }
+    this._FenceEdge.StartX = newFenceEdgeStart_x;
+    this._FenceEdge.StartY = newFenceEdgeStart_y;
+    // 添加节点
+    this._NotOccupiedEdgeList.push(curNotOccupiedEdge);
+    // 如果产生新fence,则对NotOccupiedEdgeList进行相邻节点计算
+    if (newFance) {
+      this._CalculateNeighborItem();
+    }
+  }
+
+  private _CalculateNeighborItem(tmpNeighbor: boolean = false) {
+    const templateList = this.templateList;
+    // 更新邻近边,以及未占用的边
+    for (let i = 0; i < this._NotOccupiedEdgeList.length; i++) {
+      const crossItem = this._NotOccupiedEdgeList[i];
+      const crossEdgeObj = crossItem.edgeObj;
+      const crossItemIndex = crossItem.index;
+      if (
+        crossEdgeObj.leftEdge == null &&
+        crossEdgeObj.rightEdge == null &&
+        crossEdgeObj.topEdge == null &&
+        crossEdgeObj.bottomEdge == null
+      ) {
+        this._NotOccupiedEdgeList.splice(i, 1);
+        i--;
+        continue;
+      }
+      if (this.direction === VERTICAL) {
+        // 如果下边被占用，则将其从列表中删除
+        // if (crossEdgeObj.bottomEdge === null) {
+        //   this._NotOccupiedEdgeList.splice(i, 1);
+        //   i--;
+        //   continue;
+        // }
+        // 临时邻居不触发fence edge
+        // 超过fenceedge范围，不作为对比相
+        if (
+          !tmpNeighbor && crossEdgeObj.bottomEdge != null &&
+          crossEdgeObj.bottomEdge.position > this._FenceEdge.StartY
+        ) {
+          continue;
+        }
+      } else {
+        // 如果右边被占用，则将其从列表中删除
+        // if (crossEdgeObj.rightEdge === null) {
+        //   this._NotOccupiedEdgeList.splice(i, 1);
+        //   i--;
+        //   continue;
+        // }
+        // 临时邻居不触发fence edge
+        // 超过fenceedge范围，不作为对比相
+        if (
+          !tmpNeighbor && crossEdgeObj.rightEdge &&
+          crossEdgeObj.rightEdge.position > this._FenceEdge.StartX
+        ) {
+          continue;
+        }
+      }
+
+      // 查找与交叉项上下左右最近的各项目，做交叉
+      const neighbor = this._FindNearestNeighbor(crossItem);
+      // console.log(
+      //   "%c cchtest find nearest neighbor",
+      //   "color:red;",
+      //   crossItem.index,
+      //   {
+      //     left: this._NotOccupiedEdgeList[neighbor.left]?.index,
+      //     right: this._NotOccupiedEdgeList[neighbor.right]?.index,
+      //     top: this._NotOccupiedEdgeList[neighbor.top]?.index,
+      //     bottom: this._NotOccupiedEdgeList[neighbor.bottom]?.index,
+      //   }
+      // );
+
+      for (let key in neighbor) {
+        //更新每个方向找到的邻居
+        if (neighbor[key] !== -1) {
+          const targetItem = this._NotOccupiedEdgeList[neighbor[key]];
+          this._TryUpdateItemNeighbor(
+            tmpNeighbor,
+            key,
+            crossItem,
+            targetItem
+          );
+        }
+      }
+    }
+  }
+
+  private _IfBlockedByOtherNeighbor(direction: string, crossItem: EdgeInfo, targetItem: EdgeInfo) {
+    //检查是否被其他neighbor遮挡
+    let positionKey = "top";
+    let sizeKey = "height";
+    let subPositionKey = "left";
+    switch (direction) {
+      case "left":
+        break;
+      case "right":
+        break;
+      case "top":
+        positionKey = "left";
+        subPositionKey = "top";
+        sizeKey = "width";
+        break;
+      case "bottom":
+        positionKey = "left";
+        subPositionKey = "top";
+        sizeKey = "width";
+        break;
+      default:
+        console.log(`_IfBlockedByOtherNeighbor unknown direction:${direction}`);
+        break;
+    }
+    const crossTemplateItem = this.getItemByIndex(crossItem.index);
+    const targetTemplateItem = this.getItemByIndex(targetItem.index);
+
+    let valid = true;
+    if (crossTemplateItem && targetTemplateItem) {
+      const crossNeighborList =
+        crossTemplateItem.neighborIndexList[direction];
+      const targetStart = targetTemplateItem[positionKey];
+      const targetEnd = targetStart + targetTemplateItem[sizeKey] - 1;
+      for (let i = crossNeighborList.length - 1; i >= 0; i--) {
+        const item = this.getItemByIndex(crossNeighborList[i]);
+
+        if (item == null) continue;
+
+        const itemStart = item[positionKey];
+        const itemEnd = itemStart + item[sizeKey] - 1;
+        if (itemStart <= targetEnd && itemEnd >= targetStart) {
+          //有重叠, 检查两个item那个离 cross item 更近
+          if (
+            Math.abs(
+              item[subPositionKey] - crossTemplateItem[subPositionKey]
+            ) <
+            Math.abs(
+              targetTemplateItem[subPositionKey] -
+              crossTemplateItem[subPositionKey]
+            )
+          ) {
+            //已有的neighbor更近
+            valid = false;
+            break;
+          } else {
+            //target item更近, 删除已有的neighbor
+            crossNeighborList.splice(i, 1);
+          }
+        }
+      }
+    }
+    return valid;
+  }
+
+  private _CheckNeighborItemMatching(direction: string, crossItem: EdgeInfo, targetItem: EdgeInfo) {
+    const crossEdgeObj = crossItem.edgeObj;
+    const targetEdgeObj = targetItem.edgeObj;
+    let targetEdgeName = "rightEdge";
+    let crossEdgeName = "leftEdge";
+    switch (direction) {
+      case "left":
+        targetEdgeName = "rightEdge";
+        crossEdgeName = "leftEdge";
+        break;
+      case "right":
+        targetEdgeName = "leftEdge";
+        crossEdgeName = "rightEdge";
+        break;
+      case "top":
+        targetEdgeName = "bottomEdge";
+        crossEdgeName = "topEdge";
+        break;
+      case "bottom":
+        crossEdgeName = "bottomEdge";
+        targetEdgeName = "topEdge";
+        break;
+      default:
+        console.log(
+          `_CheckNeighborItemMatching unknown direction:${direction}`
+        );
+        break;
+    }
+    // console.log(
+    //   "cchtest exclude edge",
+    //   crossItem.index,
+    //   targetItem.index,
+    //   crossEdgeName,
+    //   targetEdgeName,
+    //   crossEdgeObj[crossEdgeName].range.Clone().Ranges,
+    //   targetEdgeObj[targetEdgeName].range.Clone().Ranges
+    // );
+
+    const targetEdgeRangeClone =
+      targetEdgeObj[targetEdgeName].range.Clone();
+    targetEdgeObj[targetEdgeName].range.ExcludeRanges(
+      crossEdgeObj[crossEdgeName].range
+    );
+    crossEdgeObj[crossEdgeName].range.ExcludeRanges(
+      targetEdgeRangeClone
+    );
+
+    // console.log(
+    //   "cchtest after exclude",
+    //   crossEdgeObj[crossEdgeName].range.Clone().Ranges,
+    //   targetEdgeObj[targetEdgeName].range.Clone().Ranges
+    // );
+
+    if (targetEdgeObj[targetEdgeName].range.IsEmpty()) {
+      // 完全匹配，更新该边的状态为已被占用
+      targetEdgeObj[targetEdgeName] = null;
+    }
+
+    if (crossEdgeObj[crossEdgeName].range.IsEmpty()) {
+      // 清除该边
+      crossEdgeObj[crossEdgeName] = null;
+    }
+  }
+
+  private _FindNearestNeighbor(crossItem: EdgeInfo) {
+    const crossEdgeObj = crossItem.edgeObj;
+
+    let nearestLeftIndex = -1;
+    let nearestRightIndex = -1;
+    let nearestTopIndex = -1;
+    let nearestBottomIndex = -1;
+    let leftDistance = -1;
+    let rightDistance = -1;
+    let topDistance = -1;
+    let bottomDistance = -1;
+
+    for (let j = 0; j < this._NotOccupiedEdgeList.length; j++) {
+      const targetItem = this._NotOccupiedEdgeList[j];
+      const targetEdgeObj = targetItem.edgeObj;
+      if (crossItem === targetItem) {
+        continue;
+      }
+      // 左边最近项
+      if (
+        crossEdgeObj.leftEdge !== null &&
+        targetEdgeObj.rightEdge !== null
+      ) {
+        if (
+          crossEdgeObj.leftEdge.position >= targetEdgeObj.rightEdge.position &&
+          crossEdgeObj.leftEdge.range.IsInterAct(
+            targetEdgeObj.rightEdge.range
+          )
+        ) {
+          // 在其左侧，且有交叉，才为neighbor
+          // 计算最短距离
+          if (leftDistance === -1) {
+            leftDistance =
+              crossEdgeObj.leftEdge.position - targetEdgeObj.rightEdge.position;
+            nearestLeftIndex = j;
+            continue;
+          } else if (
+            leftDistance >
+            crossEdgeObj.leftEdge.position - targetEdgeObj.rightEdge.position
+          ) {
+            leftDistance =
+              crossEdgeObj.leftEdge.position - targetEdgeObj.rightEdge.position;
+            nearestLeftIndex = j;
+            continue;
+          }
+        }
+      }
+      // 右边最近项
+      if (
+        crossEdgeObj.rightEdge !== null &&
+        targetEdgeObj.leftEdge !== null
+      ) {
+        if (
+          crossEdgeObj.rightEdge.position <= targetEdgeObj.leftEdge.position &&
+          crossEdgeObj.rightEdge.range.IsInterAct(
+            targetEdgeObj.leftEdge.range
+          )
+        ) {
+          // 在其左侧，且有交叉，才为neighbor
+          // 计算最短距离
+          if (rightDistance === -1) {
+            rightDistance =
+              targetEdgeObj.leftEdge.position - crossEdgeObj.rightEdge.position;
+            nearestRightIndex = j;
+            continue;
+          } else if (
+            rightDistance >
+            targetEdgeObj.leftEdge.position - crossEdgeObj.rightEdge.position
+          ) {
+            rightDistance =
+              targetEdgeObj.leftEdge.position - crossEdgeObj.rightEdge.position;
+            nearestRightIndex = j;
+            continue;
+          }
+        }
+      }
+
+      // 上边最近项
+      if (
+        crossEdgeObj.topEdge !== null &&
+        targetEdgeObj.bottomEdge !== null
+      ) {
+        if (
+          crossEdgeObj.topEdge.position >= targetEdgeObj.bottomEdge.position &&
+          crossEdgeObj.topEdge.range.IsInterAct(
+            targetEdgeObj.bottomEdge.range
+          )
+        ) {
+          // 在其左侧，且有交叉，才为neighbor
+          // 计算最短距离
+          if (topDistance === -1) {
+            topDistance =
+              crossEdgeObj.topEdge.position - targetEdgeObj.bottomEdge.position;
+            nearestTopIndex = j;
+            continue;
+          } else if (
+            topDistance >
+            crossEdgeObj.topEdge.position - targetEdgeObj.bottomEdge.position
+          ) {
+            topDistance =
+              crossEdgeObj.topEdge.position - targetEdgeObj.bottomEdge.position;
+            nearestTopIndex = j;
+            continue;
+          }
+        }
+      }
+      // 下边的最近项
+      if (
+        crossEdgeObj.bottomEdge !== null &&
+        targetEdgeObj.topEdge !== null
+      ) {
+        if (
+          crossEdgeObj.bottomEdge.position <= targetEdgeObj.topEdge.position &&
+          crossEdgeObj.bottomEdge.range.IsInterAct(
+            targetEdgeObj.topEdge.range
+          )
+        ) {
+          // 在其左侧，且有交叉，才为neighbor
+          // 计算最短距离
+          if (bottomDistance === -1) {
+            bottomDistance =
+              targetEdgeObj.topEdge.position - crossEdgeObj.bottomEdge.position;
+            nearestBottomIndex = j;
+            continue;
+          } else if (
+            bottomDistance >
+            targetEdgeObj.topEdge.position - crossEdgeObj.bottomEdge.position
+          ) {
+            bottomDistance =
+              targetEdgeObj.topEdge.position - crossEdgeObj.bottomEdge.position;
+            nearestBottomIndex = j;
+            continue;
+          }
+        }
+      }
+    }
+
+    return {
+      left: nearestLeftIndex,
+      right: nearestRightIndex,
+      top: nearestTopIndex,
+      bottom: nearestBottomIndex,
+    };
+  }
+
+  private _TryUpdateItemNeighbor(tmpNeighbor: boolean, direction: string, crossItem: EdgeInfo, targetItem: EdgeInfo) {
+    const keyMap = {
+      target: {
+        left: "right",
+        right: "left",
+        top: "bottom",
+        bottom: "top",
+      },
+      cross: {
+        left: "left",
+        right: "right",
+        top: "top",
+        bottom: "bottom",
+      },
+    };
+    let crossNeighborKey = keyMap.cross[direction];
+    let targetNeighborKey = keyMap.target[direction];
+    if (!crossNeighborKey || !targetNeighborKey) {
+      console.error("_TryUpdateItemNeighbor: undefined direction", direction);
+    }
+
+    const targetIndex = targetItem.index;
+    const crossItemIndex = crossItem.index;
+    const templateList = this.templateList;
+    if (this._IfBlockedByOtherNeighbor(direction, crossItem, targetItem)) {
+      if (!tmpNeighbor) {
+        this._CheckNeighborItemMatching(direction, crossItem, targetItem);
+        // 查看是否有交集,有交集，更新临近边
+        templateList[targetIndex].neighborIndexList[targetNeighborKey].push(
+          crossItemIndex
+        );
+        templateList[crossItemIndex].neighborIndexList[
+          crossNeighborKey
+        ].push(targetIndex);
+        templateList[targetIndex].tmpNeighborIndexList[targetNeighborKey] =
+          [];
+        templateList[crossItemIndex].tmpNeighborIndexList[
+          crossNeighborKey
+        ] = [];
+      } else {
+        templateList[targetIndex].tmpNeighborIndexList[
+          targetNeighborKey
+        ].push(crossItemIndex);
+        templateList[crossItemIndex].tmpNeighborIndexList[
+          crossNeighborKey
+        ].push(targetIndex);
+      }
+    }
+  }
+}
+
+export { CommonMetroTemplate };