TypeScript ScopedLineTokens.findTokenIndexAtOffset方法代碼示例

	private _onElectricAutoIndent(character: string, context: ScopedLineTokens, column: number): IElectricAction {

		if (!this._richEditBrackets || this._richEditBrackets.brackets.length === 0) {
			return null;
		}

		let tokenIndex = context.findTokenIndexAtOffset(column - 1);
		if (ignoreBracketsInToken(context.getStandardTokenType(tokenIndex))) {
			return null;
		}

		let reversedBracketRegex = this._richEditBrackets.reversedRegex;
		let text = context.getLineContent().substring(0, column - 1) + character;

		let r = BracketsUtils.findPrevBracketInToken(reversedBracketRegex, 1, text, 0, text.length);
		if (!r) {
			return null;
		}

		let bracketText = text.substring(r.startColumn - 1, r.endColumn - 1);
		bracketText = bracketText.toLowerCase();

		let isOpen = this._richEditBrackets.textIsOpenBracket[bracketText];
		if (isOpen) {
			return null;
		}

		return {
			matchOpenBracket: bracketText
		};
	}

	private _onElectricAutoIndent(context: ScopedLineTokens, offset: number): IElectricAction {

		if (!this._richEditBrackets || this._richEditBrackets.brackets.length === 0) {
			return null;
		}

		let reversedBracketRegex = this._richEditBrackets.reversedRegex;

		let lineText = context.getLineContent();
		let tokenIndex = context.findTokenIndexAtOffset(offset);
		let tokenStart = context.getTokenStartOffset(tokenIndex);
		let tokenEnd = offset + 1;

		var firstNonWhitespaceIndex = strings.firstNonWhitespaceIndex(context.getLineContent());
		if (firstNonWhitespaceIndex !== -1 && firstNonWhitespaceIndex < tokenStart) {
			return null;
		}

		if (!ignoreBracketsInToken(context.getStandardTokenType(tokenIndex))) {
			let r = BracketsUtils.findPrevBracketInToken(reversedBracketRegex, 1, lineText, tokenStart, tokenEnd);
			if (r) {
				let text = lineText.substring(r.startColumn - 1, r.endColumn - 1);
				text = text.toLowerCase();

				let isOpen = this._richEditBrackets.textIsOpenBracket[text];
				if (!isOpen) {
					return {
						matchOpenBracket: text
					};
				}
			}
		}

		return null;
	}

	public shouldAutoClosePair(character: string, context: ScopedLineTokens, column: number): boolean {
		// Always complete on empty line
		if (context.getTokenCount() === 0) {
			return true;
		}

		let tokenIndex = context.findTokenIndexAtOffset(column - 2);
		let standardTokenType = context.getStandardTokenType(tokenIndex);

		for (let i = 0; i < this._autoClosingPairs.length; ++i) {
			let autoClosingPair = this._autoClosingPairs[i];

			if (autoClosingPair.open === character) {
				return autoClosingPair.isOK(standardTokenType);
			}
		}

		return true;
	}

	private _onElectricAutoClose(character: string, context: ScopedLineTokens, column: number): IElectricAction {
		if (!this._complexAutoClosePairs.length) {
			return null;
		}

		let line = context.getLineContent();

		for (let i = 0, len = this._complexAutoClosePairs.length; i < len; i++) {
			let pair = this._complexAutoClosePairs[i];

			// See if the right electric character was pressed
			if (character !== pair.open.charAt(pair.open.length - 1)) {
				continue;
			}

			// check if the full open bracket matches
			let start = column - pair.open.length + 1;
			let actual = line.substring(start - 1, column - 1) + character;
			if (actual !== pair.open) {
				continue;
			}

			let lastTokenIndex = context.findTokenIndexAtOffset(column - 1);
			let lastTokenStandardType = context.getStandardTokenType(lastTokenIndex);
			// If we're in a scope listed in 'notIn', do nothing
			if (!pair.isOK(lastTokenStandardType)) {
				continue;
			}

			// If this line already contains the closing tag, do nothing.
			if (line.indexOf(pair.close, column - 1) >= 0) {
				continue;
			}

			return { appendText: pair.close };
		}

		return null;
	}

	private _onElectricAutoClose(context: ScopedLineTokens, offset: number): IElectricAction {

		if (!this._complexAutoClosePairs.length) {
			return null;
		}

		var line = context.getLineContent();
		var char: string = line[offset];

		for (let i = 0; i < this._complexAutoClosePairs.length; i++) {
			let pair = this._complexAutoClosePairs[i];

			// See if the right electric character was pressed
			if (char !== pair.open.charAt(pair.open.length - 1)) {
				continue;
			}

			// If this line already contains the closing tag, do nothing.
			if (line.indexOf(pair.close, offset) >= 0) {
				continue;
			}

			// check if the full open bracket matches
			let lastTokenIndex = context.findTokenIndexAtOffset(offset);
			if (line.substring(context.getTokenStartOffset(lastTokenIndex), offset + 1/* include electric char*/) !== pair.open) {
				continue;
			}

			// If we're in a scope listed in 'notIn', do nothing
			if (!pair.isOK(context.getStandardTokenType(lastTokenIndex))) {
				continue;
			}

			return { appendText: pair.close };
		}

	}