vscode#ThemeIcon TypeScript Examples

private createItemWithCommand({
    label,
    command,
    iconId,
    iconFileName,
  }: {
    label: string;
    command?: string;
    iconId?: string;
    iconFileName?: string;
  }) {
    if (iconFileName) {
      return new StripeTreeItem(label, {
        commandString: command,
        iconPath: {
          light: path.resolve(__dirname, `../resources/icons/light/${iconFileName}.svg`),
          dark: path.resolve(__dirname, `../resources/icons/dark/${iconFileName}.svg`),
        },
      });
    } else {
      return new StripeTreeItem(label, {
        commandString: command,
        iconPath: iconId ? new ThemeIcon(iconId) : undefined,
      });
    }
  }

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

private createTreeNote(note: NoteProps) {
    const collapsibleState = _.isEmpty(note.children)
      ? TreeItemCollapsibleState.None
      : TreeItemCollapsibleState.Collapsed;

    const tn = new TreeNote({
      note,
      collapsibleState,
      labelType: this._labelType,
    });
    if (note.stub) {
      tn.iconPath = new ThemeIcon(ICONS.STUB);
    } else if (note.schema) {
      tn.iconPath = new ThemeIcon(ICONS.SCHEMA);
    }
    return tn;
  }

constructor(opts: DendronBtnCons) {
    const { iconOff, iconOn, type, title, description, pressed } = opts;
    this.iconPathNormal = new vscode.ThemeIcon(iconOff);
    this.iconPathPressed = new vscode.ThemeIcon(iconOn);
    this.type = type;
    this.description = description;
    this._pressed = pressed || false;
    this.title = title;
    this.canToggle = _.isUndefined(opts.canToggle) ? true : opts.canToggle;
    this.opts = opts;
  }

buildTree(): Promise<StripeTreeItem[]> {
    const items = [];

    const docsItem = new StripeTreeItem('Read documentation', {
      commandString: 'openDocs',
      iconPath: new ThemeIcon('book'),
    });
    items.push(docsItem);

    const reportItem = new StripeTreeItem('Report issue', {
      commandString: 'openReportIssue',
      iconPath: new ThemeIcon('report'),
    });
    items.push(reportItem);

    const feedbackItem = new StripeTreeItem('Rate and provide feedback', {
      commandString: 'openSurvey',
      iconPath: new ThemeIcon('feedback'),
    });
    items.push(feedbackItem);

    const webhooksDebugItem = new StripeTreeItem('Configure debugging', {
      commandString: 'openWebhooksDebugConfigure',
      iconPath: new ThemeIcon('settings-gear'),
    });

    items.push(webhooksDebugItem);

    return Promise.resolve(items);
  }

buildTree(): Promise<StripeTreeItem[]> {
    const items = [];

    const apiKeysItem = new StripeTreeItem('Open API keys page', {
      commandString: 'openDashboardApikeys',
      iconPath: new ThemeIcon('link-external'),
    });

    items.push(apiKeysItem);

    const eventsItem = new StripeTreeItem('Open events page', {
      commandString: 'openDashboardEvents',
      iconPath: new ThemeIcon('link-external'),
    });

    items.push(eventsItem);

    const logItem = new StripeTreeItem('Open API logs page', {
      commandString: 'openDashboardLogs',
      iconPath: new ThemeIcon('link-external'),
    });

    items.push(logItem);

    const webhooksItem = new StripeTreeItem('Open webhooks page', {
      commandString: 'openDashboardWebhooks',
      iconPath: new ThemeIcon('link-external'),
    });

    items.push(webhooksItem);

    return Promise.resolve(items);
  }

constructor(opts: DoctorBtnConstructorOpts) {
    const { iconOff, iconOn, type, title, pressed } = opts;
    this.iconPathNormal = new ThemeIcon(iconOff);
    this.iconPathPressed = new ThemeIcon(iconOn);
    this.type = type;
    this.pressed = pressed || false;
    this.title = title;

    // TODO: examine whether this is the behavior we actually want since
    // ths expression (opts.canToggle || true) will always return true
    // (as long as 'opts' is not undefined). Secondly 'this.canToggle'
    // does not appear to be used.
    this.canToggle = opts.canToggle || true;
    this.opts = opts;
  }

private getIcon(prio: number, priv: number): { light: string; dark: string } | ThemeIcon {
    switch (priv) {
      default: {
        // Public comments
        let icon = '';
        switch (prio) {
          case 3:
            icon = 'red.svg';
            break;
          case 2:
            icon = 'yellow.svg';
            break;
          case 1:
            icon = 'green.svg';
            break;
          default:
            icon = 'unset.svg';
            break;
        }

        const iPath = this.context.asAbsolutePath(path.join('dist', icon));
        return { light: iPath, dark: iPath };
      }

      case 1: {
        return new ThemeIcon(this.privateCommentIcon, themeColorForPriority(prio));
      }
    }
  }

buildTree(): Promise<StripeTreeItem[]> {
    const items = [];

    const samplesItem = new StripeTreeItem('Start with a Stripe Sample', {
      commandString: 'createStripeSample',
      iconPath: new ThemeIcon('repo-clone'),
      tooltip: 'Clone a sample integration built by Stripe',
      contextValue: 'samplesItem',
    });

    items.push(samplesItem);

    return Promise.resolve(items);
  }

buildTree(): Promise<StripeTreeItem[]> {
    const items = [];

    const createEndpoint = new StripeTreeItem('Create a new webhook endpoint', {
      commandString: 'createWebhookEndpoint',
      iconPath: new ThemeIcon('add'),
      tooltip: 'Create a new webhook endpoint',
      contextValue: 'createWebhookEndpoint',
    });
    items.push(createEndpoint);

    if (this.endpointItems.length > 0) {
      const endpointsRootItem = new StripeTreeItem('All webhook endpoints');
      endpointsRootItem.children = this.endpointItems;
      endpointsRootItem.makeCollapsible();
      items.push(endpointsRootItem);
    }

    return Promise.resolve(items);
  }

pickButtons: {
  forward: QuickInputButton;
  previous: QuickInputButton;
  next: QuickInputButton;
  close: QuickInputButton;
} = {
  forward: {
    iconPath: new ThemeIcon("arrow-right"),
    tooltip: i18n.word.forward,
  },
  previous: {
    iconPath: new ThemeIcon("arrow-up"),
    tooltip: i18n.word.previousPage,
  },
  next: {
    iconPath: new ThemeIcon("arrow-down"),
    tooltip: i18n.word.nextPage,
  },
  close: {
    iconPath: new ThemeIcon("close"),
    tooltip: i18n.word.close,
  },
}

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

public iconPathNormal: ThemeIcon;

/**
 * Open vscode input box that aids in creating of due date.
 */
export function openSetDueDateInputbox(document: TextDocument, lineNumbers: number[]) {
	const inputBox = window.createInputBox();
	let value: string | undefined = '+0';
	inputBox.value = value;
	inputBox.title = 'Set due date';
	const docsButtonName = 'Documentation';
	inputBox.onDidTriggerButton(e => {
		if (e.tooltip === docsButtonName) {
			followLink('https://github.com/usernamehw/vscode-todo-md/blob/master/docs/docs.md#set-due-date-helper-function-todomdsetduedate');
		}
	});
	inputBox.buttons = [{
		iconPath: new ThemeIcon('question'),
		tooltip: docsButtonName,
	}];
	inputBox.prompt = inputOffset(new DueDate(helpCreateDueDate(value)!).closestDueDateInTheFuture);
	inputBox.show();

	inputBox.onDidChangeValue((e: string) => {
		value = e;
		const newDueDate = helpCreateDueDate(value);
		if (!newDueDate) {
			inputBox.prompt = inputOffset('❌ Invalid');
			return;
		}
		inputBox.prompt = inputOffset(new DueDate(newDueDate).closestDueDateInTheFuture);
	});

	inputBox.onDidAccept(async () => {
		if (!value) {
			return;
		}
		const newDueDate = helpCreateDueDate(value);

		if (newDueDate) {
			const edit = new WorkspaceEdit();
			for (const line of lineNumbers) {
				setDueDateWorkspaceEdit(edit, document, line, newDueDate);
			}
			await applyEdit(edit, document);
			inputBox.hide();
			inputBox.dispose();
			updateEverything();
		}
	});
}

protected abstract readonly _iconPath: string | Uri | { light: string | Uri; dark: string | Uri } | ThemeIcon;

protected readonly _iconPath = ThemeIcon.Folder;

protected _iconPath: string | Uri | { light: string | Uri; dark: string | Uri } | ThemeIcon;

protected override _iconPath: string | Uri | { light: string | Uri; dark: string | Uri } | ThemeIcon =
        NinjaIcon["arrow-both"];

/**
   * Takes found references corresponding to a single note and turn them into
   * TreeItems
   * @param refs list of found references (for a single note)
   * @param fsPath fsPath of current note
   * @param parent parent backlink of these refs.
   * @returns list of TreeItems of found references
   */
  private getAllBacklinksInNoteFromRefs = (
    refs: FoundRefT[],
    fsPath: string,
    parent: Backlink
  ) => {
    return refs.map((ref) => {
      const lineNum = ref.location.range.start.line;
      const backlink = Backlink.createRefLevelBacklink(ref);

      backlink.iconPath = ref.isCandidate
        ? new ThemeIcon(ICONS.LINK_CANDIDATE)
        : new ThemeIcon(ICONS.WIKILINK);
      backlink.parentBacklink = parent;
      backlink.description = `on line ${lineNum + 1}`;

      backlink.command = {
        command: DENDRON_COMMANDS.GOTO_BACKLINK.key,
        arguments: [
          ref.location.uri,
          { selection: ref.location.range },
          ref.isCandidate ?? false,
        ],
        title: "Open File",
      };
      if (ref.isCandidate) {
        backlink.command = {
          command: "dendron.convertCandidateLink",
          title: "Convert Candidate Link",
          arguments: [
            { location: ref.location, text: path.parse(fsPath).name },
          ],
        };
      }
      return backlink;
    });
  };

public iconPathPressed: ThemeIcon;

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

public iconPathPressed: ThemeIcon;

public iconPathNormal: ThemeIcon;

stepInButton: QuickInputButton = {
        iconPath: new ThemeIcon("arrow-right"),
        tooltip: "Step into folder",
    };

stepOutButton: QuickInputButton = {
        iconPath: new ThemeIcon("arrow-left"),
        tooltip: "Step out of folder",
    };

actionsButton: QuickInputButton = {
        iconPath: new ThemeIcon("ellipsis"),
        tooltip: "Actions on selected file",
    };

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

override readonly iconPath = new ThemeIcon("radio-tower");

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