Top 10 Examples of "vscode in functional component" in JavaScript

constructor(
        workspaceFolder: Resource,
        private readonly interpreterAutoSelectionService: IInterpreterAutoSeletionProxyService,
        workspace?: IWorkspaceService) {
        this.workspace = workspace || new WorkspaceService();
        this.workspaceRoot = workspaceFolder ? workspaceFolder : Uri.file(__dirname);
        this.initialize();
    }
    // tslint:disable-next-line:function-name

export async function activate(context: ExtensionContext) {

	let extensionInfo = new ExtensionInfo();

	// initialize the instrumentation wrapper
	await initialize(extensionInfo.getId(), extensionInfo.getVersion(), KEY);

	try {
		// activate the extension, but send instrumentation data
		await instrumentOperation("activation", activateWithTelemetry)(context);
	}
	catch (ex) {
		// sadly, the next line never gets triggered, even if the activateWithTelemetry fails
		window.showErrorMessage("There was an error starting the PDDL extension: " + ex.message);
	}
}

private textToRange(text: string, startPosition: vscode.Position): vscode.Range {
        let parts: string[] = text.split("\n");
        let addedLines: number = parts.length - 1;
        let newStartLine: number = startPosition.line;
        let newStartCharacter: number = startPosition.character;
        let newEndLine: number = newStartLine + addedLines;
        let newEndCharacter: number = parts[parts.length - 1].length;
        if (newStartLine === newEndLine) {
            newEndCharacter += newStartCharacter;
        }
        return new vscode.Range(newStartLine, newStartCharacter, newEndLine, newEndCharacter);
    }

constructor(private svn: Svn) {
    const config = workspace.getConfiguration("svn");
    this.enabled = config.get("enabled") === true;

    svn
      .isSvnAvailable()
      .then(() => {
        if (this.enabled && svn.isSvnAvailable()) {
          this.init();
        } else {
          this.disable();
        }
      })
      .catch(() => {});
  }

function openFolder(folderPath: string) {
	let uri = Uri.file(folderPath);
	commands.executeCommand('vscode.openFolder', uri);
}

.forEach(mat => {
      const property = mat[2] || mat[3] || prop
      let pos = getPositionFromIndex(content, mat.index + mat[0].indexOf(property))
      let endPos = new Position(pos.line, pos.character + property.length)
      locs.push({
        loc: new Location(Uri.file(file), new Range(pos, endPos)),
        name: property,
        detail: mat[1] || mat[0],
      })
    })
  return locs

show(filePath: string) {
    const config = workspace.getConfiguration("files", Uri.file(filePath));
    const encoding = config.get("encoding");

    return this.repository.show(filePath, { encoding });
  }
}

private getDocumentation(
		detail: Proto.CompletionEntryDetails,
		item: MyCompletionItem
	): vscode.MarkdownString | undefined {
		const documentation = new vscode.MarkdownString();
		if (detail.source) {
			const importPath = `'${Previewer.plain(detail.source)}'`;
			const autoImportLabel = localize('autoImportLabel', 'Auto import from {0}', importPath);
			item.detail = `${autoImportLabel}\n${item.detail}`;
		}
		Previewer.addMarkdownDocumentation(documentation, detail.documentation, detail.tags);

		return documentation.value.length ? documentation : undefined;
	}

private formatDocumentation(doc: string): vscode.MarkdownString {
		var md = new vscode.MarkdownString(doc);
		md.isTrusted = true;
		return md;		
	}
}

function createNewProposal(name: string, kind: CompletionItemKind, entry?: CompletionEntry, sortPrefix?: string): CompletionItem {
  const proposal: CompletionItem = new CompletionItem(name, kind);
  if (entry) {
    if (entry.detail) {
      proposal.detail = entry.detail;
    }
    if (entry.description) {
      proposal.documentation = textToMarkdownString(entry.description);
    }
  }
  if (sortPrefix) {
    proposal.sortText = `${sortPrefix}${name}`;
  }

  return proposal;
}