TypeScript vscode-languageserver.TextDocument类代码示例

function getEOL(document: TextDocument): string {
	let text = document.getText();
	if (document.lineCount > 1) {
		let to = document.offsetAt(Position.create(1, 0));
		let from = to;
		while (from > 0 && isEOL(text, from - 1)) {
			from--;
		}
		return text.substr(from, to - from);
	}
	return '\n';
}

export async function syntaxCheck(document: TextDocument) {
  const diagnostics: Diagnostic[] = []
  try {
    const client = await clientFromUrl(document.uri)
    if (!client) return
    const obj = await getObject(document.uri)
    // no object or include without a main program
    if (!obj || !objectIsValid(obj)) return

    const source = document.getText()
    const checks = await client.syntaxCheck(
      obj.url,
      obj.mainUrl,
      source,
      obj.mainProgram
    )
    checks.forEach(c => {
      const range = sourceRange(document, c.line, c.offset)
      diagnostics.push({
        message: c.text,
        range,
        severity: decodeSeverity(c.severity)
      })
    })
  } catch (e) {
    log("Exception in syntax check:", e.toString()) // ignore
  }
  connection.sendDiagnostics({ uri: document.uri, diagnostics })
}

export function validateTextDocumentAsync(textDocument: TextDocument, options: CSpellUserSettings): Rx.Observable<Diagnostic> {
    const limit = (options.checkLimit || defaultCheckLimit) * 1024;
    const text = textDocument.getText().slice(0, limit);
    return Rx.Observable.fromPromise<cspell.TextOffset[]>(validateText(text, options))
        .flatMap(a => a)
        .filter(a => !!a)
        .map(a => a!)
        // Convert the offset into a position
        .map(offsetWord => ({...offsetWord, position: textDocument.positionAt(offsetWord.offset) }))
        // Calculate the range
        .map(word => ({
            ...word,
            range: {
                start: word.position,
                end: ({...word.position, character: word.position.character + word.text.length })
            }
        }))
        // Convert it to a Diagnostic
        .map(({text, range}) => ({
            severity: DiagnosticSeverity.Information,
            range: range,
            message: `Unknown word: "${text}"`,
            source: diagSource
        }))
    ;
}

export function validateTextDocumentAsync(textDocument: TextDocument, options: CSpellUserSettings): Observable<Diagnostic> {
    const { diagnosticLevel = DiagnosticSeverity.Information.toString() } = options;
    const severity = diagSeverityMap.get(diagnosticLevel.toLowerCase()) || DiagnosticSeverity.Information;
    const limit = (options.checkLimit || defaultCheckLimit) * 1024;
    const text = textDocument.getText().slice(0, limit);
    return from(validateText(text, options)).pipe(
        flatMap(a => a),
        filter(a => !!a),
        map(a => a!),
        // Convert the offset into a position
        map(offsetWord => ({...offsetWord, position: textDocument.positionAt(offsetWord.offset) })),
        // Calculate the range
        map(word => ({
            ...word,
            range: {
                start: word.position,
                end: ({...word.position, character: word.position.character + word.text.length })
            }
        })),
        // Convert it to a Diagnostic
        map(({text, range}) => ({
            severity,
            range: range,
            message: `"${text}": Unknown word.`,
            source: diagSource
        })),
    );
}

export function nodeMcuSignatureHelpHandler(remoteConsole: RemoteConsole, document: TextDocument, textDocumentPosition: TextDocumentPositionParams): SignatureHelp {
    remoteConsole.log("Server nodeMcuSignatureHelpHandler entered");

    let text = document.getText();
    let lineText = text.split(/\r?\n/g)[textDocumentPosition.position.line];

    let analyzeResult = analyze(lineText, textDocumentPosition.position);

    remoteConsole.log("Server nodeMcuSignatureHelpHandler word: " + JSON.stringify(analyzeResult));

    if (analyzeResult.inSignatureDefinition &&  analyzeResult.signatureName && analyzeResult.moduleName && api[analyzeResult.moduleName]) {
        let currentApi: CompletionItem[] = api[analyzeResult.moduleName];

        let filtered = currentApi.filter(function (value: CompletionItem, index: number, array: CompletionItem[]) {
            return value.label == analyzeResult.signatureName;
        });

        if (filtered.length > 0) {

            let signatureInfo: SignatureInformation = {
                label: filtered[0].detail,
                documentation: filtered[0].documentation
            };

            let result: SignatureHelp = {
                signatures: [signatureInfo],
            };

            return result;
        }
    }

    return null;
}

function assertStyleSheet(input: string, ...rules: Rule[]): void {
	let p = new Parser();
	let document = TextDocument.create('test://test/test.css', 'css', 0, input);
	let node = p.parseStylesheet(document);

	assertEntries(node, rules);
}

export function assertColor(parser: Parser, text: string, selection: string, isColor: boolean): void {
	let document = TextDocument.create('test://test/test.css', 'css', 0, text);
	let stylesheet = parser.parseStylesheet(document);
	assert.equal(0, nodes.ParseErrorCollector.entries(stylesheet).length, 'compile errors');

	let node = nodes.getNodeAtOffset(stylesheet, text.indexOf(selection));

	assert.equal(isColor, languageFacts.isColorValue(node));
}

	function getOutline(value: string): Promise<SymbolInformation[]> {
		var uri = 'test://test.json';

		var symbolProvider = new JSONDocumentSymbols();

		var document = TextDocument.create(uri, 'json', 0, value);
		var jsonDoc = Parser.parse(value);
		return symbolProvider.findDocumentSymbols(document, jsonDoc);
	}

	sortedEdits.forEach(e => {
		let startOffset = document.offsetAt(e.range.start);
		let endOffset = document.offsetAt(e.range.end);
		assert.ok(startOffset <= endOffset);
		assert.ok(endOffset <= lastOffset);
		formatted = formatted.substring(0, startOffset) + e.newText + formatted.substring(endOffset, formatted.length);
		lastOffset = startOffset;
	});

	// If the selection range just has whitespace before it in the line,
	// extend the range to account for that whitespace
	private modifyRange() {
		const { start } = this.range;
		const offset = this.document.offsetAt(start);
		const prefixLineText = this.originalText.substring(offset - start.character, offset);

		if (/^\s+$/.test(prefixLineText)) {
			this.range.start.character = 0;
		}
	}