vscode#TreeItem TypeScript Examples

constructor(namespace: string, parent: TreeItem | null) {
        super(namespace, TreeItemCollapsibleState.Collapsed);
        this._parent = parent;
        if (parent instanceof QDictTreeItem) {
            parent.appendChild(this);
        }
        this.isExpanded = false;
        setCommand(this);
        this.iconPath = {
            light: path.join(__filename, '../../assets/svg/item/dict.svg'),
            dark: path.join(__filename, '../../assets/svg/item/dict.svg')
        };
    }

export class TagTreeItem extends TreeItem {
	readonly collapsibleState = TreeItemCollapsibleState.Collapsed;

	constructor(
		readonly label: string,
		readonly tasks: TheTask[],
	) {
		super(label);
	}

	contextValue = 'tag';
}

getChildren(e?: TreeItem): Thenable<TreeItem[]> {
        if (e instanceof HistoryTreeItem) {
            return Promise.resolve(e._children);
        } else if (e) {
            return Promise.resolve([]);
        } else {
            return Promise.resolve(this._children);
        }
    }

export class ProjectTreeItem extends TreeItem {
	readonly collapsibleState = TreeItemCollapsibleState.Collapsed;

	constructor(
		readonly label: string,
		readonly tasks: TheTask[],
	) {
		super(label);
	}

	contextValue = 'project';
}

getChildren(e?: TreeItem): Thenable<TreeItem[]> {
        if (e instanceof QDictTreeItem) {
            return Promise.resolve(e._children);
        } else if (e) {
            return Promise.resolve([]);
        } else {
            return Promise.resolve(this._children);
        }
    }

private buildItemFromDriveFile(currentFile: DriveFile): TreeItem {
        const iconUri = Uri.parse(currentFile.iconLink);
        const collapsible = this.detectCollapsibleState(currentFile);
        const contextValue = DriveFileUtils.extractTextFromType(currentFile.type);
        return {
            iconPath: iconUri,
            label: currentFile.name,
            collapsibleState: collapsible,
            contextValue: contextValue
        };
    }

getChildren(e?: TreeItem): Thenable<TreeItem[]> {
        if (e instanceof QServerTree) {
            return Promise.resolve(e.getChildren());
        } else if (e instanceof QConn) {
            return Promise.resolve([]);
        } else {
            return Promise.resolve(
                this._children
            );
        }
    }

public async getChildren(element?: TreeItem): Promise<TreeItem[]> {
    if (!this.treeItems) {
      this.treeItems = await this.buildTree();
    }

    if (element instanceof StripeTreeItem) {
      return element.children;
    }

    if (!element) {
      if (this.treeItems) {
        return this.treeItems;
      }
    }
    return [];
  }

export function setCommand(item: TreeItem): void {
    item.command = {
        command: 'q-explorer.click',
        title: 'click',
        arguments: [item.label]
    };
}

export class CommandsTreeDataProvider implements vscode.TreeDataProvider<TreeItem> {

	data: vscode.TreeItem[];

	constructor() {
		this.data = [
			makeTreeItem('clean', 'reach.clean'),
			makeTreeItem('compile', 'reach.compile'),
			makeTreeItem('devnet', 'reach.devnet'),
			makeTreeItem('docker-reset', 'reach.docker-reset'),
			makeTreeItem('down', 'reach.down'),
			makeTreeItem('hashes', 'reach.hashes'),
			makeTreeItem('init', 'reach.init'),
			makeTreeItem('react', 'reach.react'),
			makeTreeItem('rpc-run', 'reach.rpc-run'),
			makeTreeItem('rpc-server', 'reach.rpc-server'),
			makeTreeItem('run', 'reach.run'),
			makeTreeItem('scaffold', 'reach.scaffold'),
			makeTreeItem('update', 'reach.update'),
			makeTreeItem('upgrade', 'reach.upgrade'),
			makeTreeItem('version', 'reach.version'),
		];
	}

	getTreeItem(element: TreeItem) {
		return element;
	}

	getChildren(_?: TreeItem|undefined) {
		return this.data;
	}
}

export default class QFunctionTreeItem extends TreeItem {
    contextValue = 'qfunction';
    _parent: TreeItem;
    _body: string;

    constructor(name: string, parent: QDictTreeItem, body: string) {
        super(name, TreeItemCollapsibleState.None);
        this._parent = parent;
        this._body = body;
        parent.appendChild(this);
        setCommand(this);
        const md = new MarkdownString();
        md.appendCodeblock(this._body, 'q');
        this.tooltip = md;
        this.iconPath = {
            light: path.join(__filename, '../../assets/svg/item/function.svg'),
            dark: path.join(__filename, '../../assets/svg/item/function.svg')
        };
    }

    getBody(): string {
        return this._body;
    }

    getParent(): TreeItem {
        return this._parent;
    }

    getTreeItem(e: QFunctionTreeItem): TreeItem {
        return e;
    }

}

export class DocumentationTreeDataProvider implements vscode.TreeDataProvider<TreeItem> {

	data: vscode.TreeItem[];

	constructor() {
		this.data = [
			makeLabeledTreeItem('docs', 'Open the documentation', 'reach.docs', reach_icon_red),
		];
	}

	getTreeItem(element: TreeItem) {
		return element;
	}

	getChildren(_?: TreeItem|undefined) {
		return this.data;
	}
}

export class NodeTreeItem extends TreeItem {
  collapsibleState = TreeItemCollapsibleState.Collapsed;
  key: string;
  url: string;

  constructor(node: Node) {
    super(node.label);
    this.key = node.key;
    this.url = node.url;
    if (node.iconPath !== undefined) {
      this.iconPath = node.iconPath;
    }
    this.command = {
      command: "vscode.open",
      title: "Select Node",
      arguments: [Uri.file(node.url)],
    };
  }
}

public getExpandableTreeItems(): TreeItem[] {
    const candidateItems = _.toArray(
      _.pickBy(this._tree, (item) => {
        const isCollapsed =
          item.collapsibleState === TreeItemCollapsibleState.Collapsed;
        const isShallow = DNodeUtils.getDepth(item.note) < 3;
        return isCollapsed && isShallow;
      })
    );
    return _.sortBy(candidateItems, (item) => {
      return DNodeUtils.getDepth(item.note);
    });
  }

export class TaskTreeItem extends TreeItem {
	collapsibleState = TreeItemCollapsibleState.None;
	contextValue = 'task';

	constructor(
		readonly label: string,
		readonly task: TheTask,
		readonly command: Command,
	) {
		super(label);
		if (task.links.length) {
			this.contextValue = 'link';
		}
		if (task.subtasks.length) {
			if (task.isCollapsed) {
				this.collapsibleState = TreeItemCollapsibleState.Collapsed;
			} else {
				this.collapsibleState = TreeItemCollapsibleState.Expanded;
			}
		}

		if (task.done) {
			this.iconPath = new ThemeIcon('pass', new ThemeColor('todomd.treeViewCompletedTaskIcon'));
		} else {
			// this.iconPath = new ThemeIcon('circle-large-outline');// TODO: maybe
		}
	}
}

getTreeItem(element: MenuItem): TreeItem {
    let iconPath: vscode.ThemeIcon;

    switch (element) {
      case MenuItem.getStarted:
        iconPath = new ThemeIcon("star");
        break;

      case MenuItem.readDocs:
        iconPath = new ThemeIcon("book");
        break;

      case MenuItem.reviewIssues:
        iconPath = new ThemeIcon("issues");
        break;

      case MenuItem.reportIssue:
        iconPath = new ThemeIcon("comment");
        break;

      case MenuItem.joinCommunity:
        iconPath = new ThemeIcon("organization");
        break;

      case MenuItem.followUs:
        iconPath = new ThemeIcon("twitter");
        break;

      default:
        assertUnreachable(element);
    }

    return {
      label: element.toString(),
      collapsibleState: TreeItemCollapsibleState.None,
      iconPath,
    };
  }

export class LocalLibraryTreeItem extends TreeItem {
  override readonly label!: string;

  override readonly tooltip = this.label;

  override readonly iconPath = new ThemeIcon("file-directory");

  override readonly contextValue = "LocalLibraryTreeItem";

  constructor(label: string) {
    super(label, TreeItemCollapsibleState.Collapsed);
  }
}

//#region Interface implementations

    // Implements TreeDataProvider<Node>
    public getTreeItem(element: Node): TreeItem {
        const item = element.getTreeItem();

        if (element instanceof DecorableNode && element.decoration) {
            this.decorate(element, element.decoration);
        }

        if (item.id) {
            item.id = `${item.id}.${item.collapsibleState}.${this._expandCollapseController.iteration}`;
            const state = this._expandCollapseController.getState(element, element.collapsibleState);
            if (state !== undefined && item.collapsibleState !== TreeItemCollapsibleState.None) {
                item.collapsibleState = state;
            }
        }
        return item;
    }

export class CommentListEntry extends TreeItem {
  constructor(
    public readonly id: string,
    public readonly label: string,
    public readonly text: string,
    public readonly hoverLabel: string,
    public readonly collapsibleState: TreeItemCollapsibleState,
    public readonly data: ReviewFileExportSection,
    public readonly prio?: number,
    public readonly priv?: number,
  ) {
    super(label, collapsibleState);
  }

  get tooltip(): string {
    return this.hoverLabel;
  }

  get description(): string {
    return this.text || '';
  }
}

protected override completeTreeItem(item: TreeItem): void {
        super.completeTreeItem(item);

        const ninjaRange = this._range as unknown as NinjaALRange;
        if (ninjaRange && ninjaRange.description) {
            if (this._includeLogicalNameInDescription) {
                item.description = ninjaRange.description;
            }
            if (this._includeLogicalNameInLabel) {
                item.label = `${item.label} (${ninjaRange.description})`;
            }
        }

        if (this._noConsumption) {
            item.description = `${item.description || ""} (no consumption)`.trim();
        }
    }

export class RadioTreeItem extends TreeItem {
  private static readonly _set = new Map<number, RadioTreeItem>();

  override readonly label!: string;

  override readonly tooltip = `${i18n.word.description}: ${this.item.desc || ""}
${i18n.word.trackCount}: ${this.item.programCount}
${i18n.word.playCount}: ${this.item.playCount}
${i18n.word.subscribedCount}: ${this.item.subCount}`;

  override readonly iconPath = new ThemeIcon("rss");

  override readonly contextValue = "RadioTreeItem";

  constructor(readonly item: NeteaseTypings.RadioDetail, public uid: number) {
    super(item.name, TreeItemCollapsibleState.Collapsed);
  }

  override get valueOf(): number {
    return this.item.id;
  }

  static new(item: NeteaseTypings.RadioDetail, uid = 0): RadioTreeItem {
    let element = this._set.get(item.id);
    if (element) {
      element.uid = uid;
      return element;
    }
    element = new this(item, uid);
    this._set.set(item.id, element);
    return element;
  }
}

public getTreeItem(): TreeItem {
        const item = new TreeItem(this._label, this._collapsibleState);

        if (this._description) {
            item.description = this._description;
        }

        if (this._tooltip !== undefined) {
            item.tooltip = this._tooltip;
        }

        if (this._contextValues.length > 0) {
            item.contextValue = ["", ...this._contextValues, ""].join(",");
        }

        this.completeTreeItem(item);

        return item;
    }

export class UserTreeItem extends TreeItem {
  private static readonly _set = new Map<number, UserTreeItem>();

  override readonly iconPath = new ThemeIcon("account");

  override readonly contextValue = "UserTreeItem";

  constructor(override readonly label: string, readonly uid: number) {
    super(label, TreeItemCollapsibleState.Collapsed);
  }

  static new(label: string, uid: number): UserTreeItem {
    let element = this._set.get(uid);
    if (element) return element;
    element = new this(label, uid);
    this._set.set(uid, element);
    return element;
  }
}

getTreeItem(element: TreeItem) {
		return element;
	}

export class StripeTreeViewDataProvider implements TreeDataProvider<TreeItem> {
  private treeItems: TreeItem[] | null = null;
  private _onDidChangeTreeData: EventEmitter<TreeItem | null> = new EventEmitter<TreeItem | null>();
  readonly onDidChangeTreeData: Event<TreeItem | null> = this._onDidChangeTreeData.event;

  public refresh() {
    this.treeItems = null;
    this._onDidChangeTreeData.fire(null);
  }

  public getTreeItem(element: TreeItem): TreeItem {
    return element;
  }

  public getParent(element: TreeItem): TreeItem | null {
    if (element instanceof StripeTreeItem && element.parent) {
      return element.parent;
    }
    return null;
  }

  public async getChildren(element?: TreeItem): Promise<TreeItem[]> {
    if (!this.treeItems) {
      this.treeItems = await this.buildTree();
    }

    if (element instanceof StripeTreeItem) {
      return element.children;
    }

    if (!element) {
      if (this.treeItems) {
        return this.treeItems;
      }
    }
    return [];
  }

  buildTree(): Promise<StripeTreeItem[]> {
    return Promise.resolve([]);
  }
}

_parent: TreeItem;

getTreeItem(element: ContextTreeItem | TaskTreeItem): TreeItem {
		return element;
	}

protected override completeTreeItem(item: TreeItem) {
        item.resourceUri = this.uri;
        item.id = `${this.uri.toString()}`;
        item.iconPath = this._iconPath;
    }

export default abstract class AbstractNode extends TreeItem {
    fullPath: string;
    abstract getChildren(): Promise<AbstractNode[]>;
    public copyPath() {
        Util.copyToBoard(this.fullPath)
    }
}