SCCommon/tree/src/nodeCtx.ts

import { TreeNode, Tree, None } from './tree';

export class NodeContext {
  // 对树节点数据的引用
  ref: TreeNode;

  tree: Tree;

  // 展开收起
  expanded = false;

  constructor(node: TreeNode, tree: Tree) {
    this.ref = node;
    this.tree = tree;
  }

  ID(): string {
    return this.ref.ID;
  }

  parentID(): string {
    return this.ref.parentID;
  }

  // 节点在完整、排好序的树数据中的行号
  row(): number {
    return this.tree.data.indexOf(this.ref);
  }

  // 获取树结构展开显示的行号
  visualRow(): number {
    let row = 0;
    for (const n of this.tree.data) {
      if (this.ref === n) return row;
      if (n.getCtx().visible()) {
        row += 1;
      }
    }
    return row;
  }

  // 节点在相同父节点下的行号
  rowInParent(): number {
    return this.brothers().indexOf(this.ref);
  }

  // 节点的原始seq数据
  seq(): number {
    return this.ref.seq;
  }

  // 节点深度，根节点深度为0
  depth(): number {
    const parent = this.parent();
    return parent ? parent.getCtx().depth() + 1 : 0;
  }

  // 节点是否可见，根据先代节点的expanded就可以计算出来，不需要维护visible属性
  visible(): boolean {
    let parent = this.parent();
    while (parent) {
      if (!parent.getCtx().expanded) {
        return false;
      }
      parent = parent.getCtx().parent();
    }
    return true;
  }

  parent(): TreeNode | None {
    return this.tree.findParent(this.ID());
  }

  next(): TreeNode | None {
    return this.tree.findNext(this.ID());
  }

  prev(): TreeNode | None {
    return this.tree.findPrev(this.ID());
  }

  // 获取节点子项
  children(): TreeNode[] {
    return this.tree.parentMap[this.ID()] || [];
  }

  firstChild(): TreeNode | None {
    return this.children()[0] || null;
  }

  lastChild(): TreeNode | None {
    const children = this.children();
    return children[children.length - 1] || null;
  }

  // 获取节点后代（包含嵌套子项）
  posterity(): TreeNode[] {
    const posterity: TreeNode[] = [];
    const getChild = (nodes: TreeNode[]): void => {
      nodes.forEach(node => {
        posterity.push(node);
        const children = node.getCtx().children();
        if (children.length) {
          getChild(children);
        }
      });
    };
    getChild(this.children());
    return posterity;
  }

  posterityCount(): number {
    return this.posterity().length;
  }

  // 获取节点最上层的父项（起源）
  progenitor(): TreeNode | None {
    let parent = this.parent();
    while (parent && parent.getCtx().parent()) {
      parent = parent.getCtx().parent();
    }
    return parent;
  }

  // 获取节点所有先代（包含嵌套父项）
  ancestor(): TreeNode[] {
    const ancestor: TreeNode[] = [];
    let parent = this.parent();
    while (parent) {
      ancestor.push(parent);
      parent = parent.getCtx().parent();
    }
    return ancestor;
  }

  ancestorCount(): number {
    return this.ancestor().length;
  }

  // 获取同层节点
  brothers(includeSelf = true): TreeNode[] {
    let nodes = this.tree.parentMap[this.parentID()] || [];
    if (!includeSelf) {
      nodes = nodes.filter(node => node !== this.ref);
    }
    return nodes;
  }

  brothersCount(includeSelf = true): number {
    return this.brothers(includeSelf).length;
  }

  // 获取后兄弟节点们
  nextBrothers(): TreeNode[] {
    const nodes = this.tree.parentMap[this.parentID()] || [];
    return nodes.filter(node => node.seq >= this.seq() && node !== this.ref);
  }

  // 获取前兄弟节点们
  prevBrothers(): TreeNode[] {
    const nodes = this.tree.parentMap[this.parentID()] || [];
    return nodes.filter(node => node.seq <= this.seq() && node !== this.ref);
  }

  // 只有前节点存在才可上移
  canUpMove(): boolean {
    return !!this.prev();
  }

  // 只有后节点存在才可下移
  canDownMove(): boolean {
    return !!this.next();
  }

  // 只有父节点存在才可升级
  canUpLevel(): boolean {
    return !!this.parent();
  }

  // 只有前节点存在才可降级
  canDownLevel(): boolean {
    return !!this.prev();
  }
}