vscode#TreeItemCollapsibleState TypeScript Examples

constructor(public item: JoplinListFolder | JoplinListNote) {
    super(
      item.title,
      item.type_ === TypeEnum.Folder
        ? vscode.TreeItemCollapsibleState.Collapsed
        : TreeItemCollapsibleState.None,
    )
    const iconName = FolderOrNote.getIconName(item)
    this.iconPath = {
      light: path.resolve(__dirname, `../resources/light/${iconName}.svg`),
      dark: path.resolve(__dirname, `../resources/dark/${iconName}.svg`),
    }
    if (item.type_ === TypeEnum.Note) {
      this.command = {
        command: 'joplinNote.openNote',
        title: this.item.title,
        arguments: [this],
      }
    }
  }

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);
    });
  }

private constructor(history: History, parent: TreeItem | null) {
        super(history.uniqLabel.replace(',', '-') + ' | ' + dayjs(history.time).format('HH:mm:ss'), TreeItemCollapsibleState.None);
        this.uniqLabel = history.uniqLabel;
        this.query = history.query;
        this.time = history.time;
        this.duration = history.duration;
        this._parent = parent;
        this.errorMsg = history.errorMsg;
        const mdString = new MarkdownString();
        mdString.appendMarkdown(`- server: ${history.uniqLabel.replace(',', '-')}\n`);
        mdString.appendMarkdown(`- time: ${dayjs(history.time).format('YYYY.MM.DD HH:mm:ss.SSS')}\n`);
        mdString.appendMarkdown(`- duration: ${history.duration}\n`);

        if (this.errorMsg) {
            mdString.appendMarkdown('- error:');
            mdString.appendCodeblock(this.errorMsg, 'q');
        } else {
            mdString.appendMarkdown('- query:');
            mdString.appendCodeblock(history.query, 'q');
        }
        this.tooltip = mdString;
    }

constructor(readonly sshConfig: SSHConfig, readonly name: string, readonly file?: FileEntry, readonly parentName?: string, iconPath?: string) {
        super(name, TreeItemCollapsibleState.Collapsed);
        this.id = file ? `${sshConfig.username}@${sshConfig.host}_${sshConfig.port}_${parentName}.${name}` : `${sshConfig.username}@${sshConfig.host}:${sshConfig.port}`;
        this.fullPath = this.parentName + this.name;
        if (!file) {
            this.contextValue = NodeType.CONNECTION;
            this.iconPath = path.join(ServiceManager.context.extensionPath, 'resources', 'image', `chain.svg`);
        } else {
            this.contextValue = NodeType.FOLDER;
            this.iconPath = path.join(ServiceManager.context.extensionPath, 'resources', 'image', `folder.svg`);
        }
        if (file && file.filename.toLocaleLowerCase() == "home") {
            this.iconPath = `${ServiceManager.context.extensionPath}/resources/image/folder-core.svg`;
        } else if (iconPath) {
            this.iconPath = iconPath;
        }
    }

addChild(item: StripeTreeItem) {
    this.children.push(item);
    if (this.children.length) {
      if (this.collapsibleState !== TreeItemCollapsibleState.Expanded) {
        this.makeCollapsible();
      }
    }
    return this;
  }

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
		}
	}

constructor(app: ALApp, view: ViewController) {
        super(undefined);

        this._app = app;
        this._view = view;
        this._label = app.name || app.manifest.name;
        this._description = app.manifest.version;
        this._tooltip = `${app.manifest.name} v${app.manifest.version}`;
        this._uriAuthority = app.hash;
        this._collapsibleState = TreeItemCollapsibleState.Expanded;
        this._contextValues.push(ContextValues.Sync);
    }

private constructor(
    label: string,
    refs: FoundRefT[] | undefined,
    collapsibleState: vscode.TreeItemCollapsibleState,
    public readonly treeItemType: BacklinkTreeItemType,
    singleRef: FoundRefT | undefined
  ) {
    super(label, collapsibleState);

    if (refs) {
      this.refs = refs.map((r) => ({ ...r, parentBacklink: this }));
    } else {
      this.refs = undefined;
    }

    if (singleRef) {
      this.singleRef = singleRef;
    }
  }

protected calculateChildren(): Node[] {
        const children: Node[] = [];
        for (let key of Object.values<string>(ALObjectType)) {
            const type = key as ALObjectType;
            if (this._consumption[type] === undefined || this._consumption[type].length === 0) {
                continue;
            }
            const ids = this._consumption[type].filter(id => id >= this.range.from && id <= this.range.to);
            if (ids.length === 0) {
                continue;
            }
            children.push(new ObjectTypeConsumptionNode(this, key, ids, this.size));
        }

        if (children.length === 0) {
            this._noConsumption = true;
            this._collapsibleState = TreeItemCollapsibleState.None;
            this._decoration = {
                badge: "-",
                severity: DecorationSeverity.inactive,
                tooltip: `No consumption has been recorded`,
            };
            this._iconPath = NinjaIcon["arrow-both-inactive"];
        } else {
            this._decoration = undefined;
        }

        return children;
    }

private createPackageData(packages: Package[]): PackageTreeItem[] {
        let packageItems: PackageTreeItem[] = [];
        packages.sort((package1, package2) => {
            return package1.name.localeCompare(package2.name!);
        });
        packages.forEach(projectPackage => {
            projectPackage.name = projectPackage.name === '.' ? window.activeTextEditor!.document.fileName
                .replace('.bal', '').split(sep).pop()!.toString() : projectPackage.name;
            if (projectPackage.name) {
                packageItems.push(new PackageTreeItem(projectPackage.name, '',
                    TreeItemCollapsibleState.Expanded, PROJECT_KIND.PACKAGE, fileUriToPath(projectPackage.filePath),
                    this.extensionPath, true, null, { modules: projectPackage.modules }));
            }
        });
        return packageItems;
    }

constructor(readonly sshConfig: SSHConfig, readonly file: FileEntry, readonly parentName: string) {
        super(file.filename, TreeItemCollapsibleState.None)
        this.description = prettyBytes(file.attrs.size)
        this.iconPath = this.getIcon(this.file.filename)
        this.fullPath = this.parentName + this.file.filename;
        this.command = {
            command: "ssh.file.open",
            arguments: [this],
            title: "Open File"
        }
    }

/**
      * Returns the tree structure for resources.
      * @returns An array of tree nodes with resource data.
      */
    private getResourceStructure(parent: PackageTreeItem): PackageTreeItem[] {
        let resources: PackageTreeItem[] = [];
        const children: ChildrenData = parent.getChildrenData();
        if (children.resources) {
            const resourceNodes = children.resources;
            resourceNodes.sort((resource1, resource2) => {
                return resource1.name!.localeCompare(resource2.name!);
            });
            resourceNodes.forEach(resource => {
                resources.push(new PackageTreeItem(resource.name, '',
                    TreeItemCollapsibleState.None, PROJECT_KIND.RESOURCE, parent.getFilePath(), this.extensionPath, true,
                    parent, {}, resource.startLine, resource.startColumn, resource.endLine, resource.endColumn));
            });
        }
        return resources;
    }

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);
  }

public static createRefLevelBacklink(reference: FoundRefT): Backlink {
    return new Backlink(
      reference.matchText,
      undefined,
      TreeItemCollapsibleState.None,
      BacklinkTreeItemType.referenceLevel,
      reference
    );
  }

constructor(info: string) {
        super(info)
        this.collapsibleState = TreeItemCollapsibleState.None
    }

protected abstract _collapsibleState: TreeItemCollapsibleState;

constructor(info: string) {
        super(info)
        this.iconPath={
            light: Util.getExtPath("resources", "image", "light", "link.svg"),
            dark: Util.getExtPath("resources", "image","dark", "link.svg"),
        }
        this.collapsibleState = TreeItemCollapsibleState.None
    }

expand() {
    this.collapsibleState = TreeItemCollapsibleState.Expanded;
  }

protected readonly _collapsibleState: TreeItemCollapsibleState;

collapsibleState = TreeItemCollapsibleState.None;

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

/**
     * Returns the tree structure for functions and services.
     * @returns An array of tree nodes with module component data.
     */
    private getComponentStructure(parent: PackageTreeItem, isDefaultModule: boolean = false,
        childrenData: ChildrenData = {}): PackageTreeItem[] {
        let components: PackageTreeItem[] = [];
        const children: ChildrenData = isDefaultModule ? childrenData : parent.getChildrenData();
        //Process function nodes
        if (children.functions) {
            const functionNodes = children.functions;
            functionNodes.sort((fn1, fn2) => {
                return fn1.name!.localeCompare(fn2.name!);
            });
            functionNodes.forEach(fn => {
                components.push(new PackageTreeItem(fn.name, `${fn.filePath}`, TreeItemCollapsibleState.None,
                    PROJECT_KIND.FUNCTION, join(parent.getFilePath(), fn.filePath), this.extensionPath, true, parent,
                    {}, fn.startLine, fn.startColumn, fn.endLine, fn.endColumn));
            });
        }

        //Process service nodes
        if (children.services) {
            const serviceNodes = children.services.filter(service => {
                return service.name;
            });
            serviceNodes.sort((service1, service2) => {
                return service1.name!.localeCompare(service2.name!);
            });
            serviceNodes.forEach(service => {
                components.push(new PackageTreeItem(service.name, `${service.filePath}`,
                    TreeItemCollapsibleState.Collapsed, PROJECT_KIND.SERVICE, join(parent.getFilePath(),
                        service.filePath), this.extensionPath, true, parent, { resources: service.resources },
                    service.startLine, service.startColumn, service.endLine, service.endColumn));
            });

            const serviceNodesWithoutName = children.services.filter(service => {
                return !service.name;
            });
            let count: number = 0;
            serviceNodesWithoutName.forEach(service => {
                components.push(new PackageTreeItem(`${PROJECT_KIND.SERVICE} ${++count}`, `${service.filePath}`,
                    TreeItemCollapsibleState.Collapsed, PROJECT_KIND.SERVICE, join(parent.getFilePath(),
                        service.filePath), this.extensionPath, true, parent, { resources: service.resources },
                    service.startLine, service.startColumn, service.endLine, service.endColumn));
            });
        }
        return components;
    }

public getFilesContainingComments(): Thenable<CommentListEntry[]> {
    if (!fs.existsSync(this.absoluteFilePath) || !this.generator.check()) {
      return Promise.resolve([]);
    }

    const entries: CsvEntry[] = [];

    return new Promise((resolve) => {
      parseFile(this.absoluteFilePath, { delimiter: ',', ignoreEmpty: true, headers: true })
        .on('error', () => this.handleError)
        .on('data', (row: CsvEntry) => {
          if (this.isCommentEligible(row)) {
            entries.push(row);
          }
        })
        .on('end', () => {
          const sortedByFile = this.groupResults(entries, Group.filename);
          const listEntries = sortedByFile.map((el: ReviewFileExportSection, index: number) => {
            const item = new CommentListEntry(
              '',
              el.group,
              `(${el.lines.length})`,
              `${el.lines.length} comments`,
              // Expand the first (and only) file when in filtered by filename mode
              this.filterByFilename && index === 0
                ? TreeItemCollapsibleState.Expanded
                : TreeItemCollapsibleState.Collapsed,
              el,
            );
            item.command = {
              command: 'codeReview.openSelection',
              title: 'reveal comment',
              arguments: [el],
            };
            item.contextValue = 'file';
            item.iconPath = {
              light: this.context.asAbsolutePath(path.join('dist', 'document-light.svg')),
              dark: this.context.asAbsolutePath(path.join('dist', 'document-dark.svg')),
            };

            return item;
          });

          resolve(listEntries);
        });
    });
  }

collapsibleState = TreeItemCollapsibleState.Collapsed;

private _treeState: WeakMap<Node, TreeItemCollapsibleState | undefined> = new WeakMap();

constructor(label: string, parent: TreeItem | null) {
        super(label, TreeItemCollapsibleState.Collapsed);
        this._parent = parent;
    }

makeCollapsible() {
    this.collapsibleState = TreeItemCollapsibleState.Collapsed;
  }

private detectCollapsibleState(currentFile: DriveFile): TreeItemCollapsibleState {
        const collapsible = currentFile.type == FileType.DIRECTORY ?
            TreeItemCollapsibleState.Collapsed :
            TreeItemCollapsibleState.None;
        return collapsible;
    }

readonly collapsibleState = TreeItemCollapsibleState.Collapsed;