Fix explicit access

This commit is contained in:
Daniel Imms
2020-04-14 06:23:11 -07:00
parent a5ebb6d98c
commit 9817754f92
31 changed files with 303 additions and 303 deletions
+166 -166
View File
@@ -19,342 +19,342 @@ import { IParams, IFunctionIdentifier } from 'common/parser/Types';
import { ISelectionService } from 'browser/services/Services';
export class TestTerminal extends Terminal {
get curAttrData(): IAttributeData { return (this as any)._inputHandler._curAttrData; }
keyDown(ev: any): boolean { return this._keyDown(ev); }
keyPress(ev: any): boolean { return this._keyPress(ev); }
public get curAttrData(): IAttributeData { return (this as any)._inputHandler._curAttrData; }
public keyDown(ev: any): boolean { return this._keyDown(ev); }
public keyPress(ev: any): boolean { return this._keyPress(ev); }
}
export class MockTerminal implements ITerminal {
onBlur: IEvent<void>;
onFocus: IEvent<void>;
onA11yChar: IEvent<string>;
onA11yTab: IEvent<number>;
onCursorMove: IEvent<void>;
onLineFeed: IEvent<void>;
onSelectionChange: IEvent<void>;
onData: IEvent<string>;
onBinary: IEvent<string>;
onTitleChange: IEvent<string>;
onScroll: IEvent<number>;
onKey: IEvent<{ key: string, domEvent: KeyboardEvent }>;
onRender: IEvent<{ start: number, end: number }>;
onResize: IEvent<{ cols: number, rows: number }>;
markers: IMarker[];
optionsService: IOptionsService;
unicodeService: IUnicodeService;
addMarker(cursorYOffset: number): IMarker {
public onBlur: IEvent<void>;
public onFocus: IEvent<void>;
public onA11yChar: IEvent<string>;
public onA11yTab: IEvent<number>;
public onCursorMove: IEvent<void>;
public onLineFeed: IEvent<void>;
public onSelectionChange: IEvent<void>;
public onData: IEvent<string>;
public onBinary: IEvent<string>;
public onTitleChange: IEvent<string>;
public onScroll: IEvent<number>;
public onKey: IEvent<{ key: string, domEvent: KeyboardEvent }>;
public onRender: IEvent<{ start: number, end: number }>;
public onResize: IEvent<{ cols: number, rows: number }>;
public markers: IMarker[];
public optionsService: IOptionsService;
public unicodeService: IUnicodeService;
public addMarker(cursorYOffset: number): IMarker {
throw new Error('Method not implemented.');
}
selectLines(start: number, end: number): void {
public selectLines(start: number, end: number): void {
throw new Error('Method not implemented.');
}
scrollToLine(line: number): void {
public scrollToLine(line: number): void {
throw new Error('Method not implemented.');
}
static string: any;
setOption(key: any, value: any): void {
public static string: any;
public setOption(key: any, value: any): void {
throw new Error('Method not implemented.');
}
blur(): void {
public blur(): void {
throw new Error('Method not implemented.');
}
focus(): void {
public focus(): void {
throw new Error('Method not implemented.');
}
resize(columns: number, rows: number): void {
public resize(columns: number, rows: number): void {
throw new Error('Method not implemented.');
}
writeln(data: string): void {
public writeln(data: string): void {
throw new Error('Method not implemented.');
}
paste(data: string): void {
public paste(data: string): void {
throw new Error('Method not implemented.');
}
open(parent: HTMLElement): void {
public open(parent: HTMLElement): void {
throw new Error('Method not implemented.');
}
attachCustomKeyEventHandler(customKeyEventHandler: (event: KeyboardEvent) => boolean): void {
public attachCustomKeyEventHandler(customKeyEventHandler: (event: KeyboardEvent) => boolean): void {
throw new Error('Method not implemented.');
}
addCsiHandler(id: IFunctionIdentifier, callback: (params: IParams) => boolean): IDisposable {
public addCsiHandler(id: IFunctionIdentifier, callback: (params: IParams) => boolean): IDisposable {
throw new Error('Method not implemented.');
}
addDcsHandler(id: IFunctionIdentifier, callback: (data: string, param: IParams) => boolean): IDisposable {
public addDcsHandler(id: IFunctionIdentifier, callback: (data: string, param: IParams) => boolean): IDisposable {
throw new Error('Method not implemented.');
}
addEscHandler(id: IFunctionIdentifier, handler: () => boolean): IDisposable {
public addEscHandler(id: IFunctionIdentifier, handler: () => boolean): IDisposable {
throw new Error('Method not implemented.');
}
addOscHandler(ident: number, callback: (data: string) => boolean): IDisposable {
public addOscHandler(ident: number, callback: (data: string) => boolean): IDisposable {
throw new Error('Method not implemented.');
}
registerLinkMatcher(regex: RegExp, handler: (event: MouseEvent, uri: string) => boolean | void, options?: ILinkMatcherOptions): number {
public registerLinkMatcher(regex: RegExp, handler: (event: MouseEvent, uri: string) => boolean | void, options?: ILinkMatcherOptions): number {
throw new Error('Method not implemented.');
}
deregisterLinkMatcher(matcherId: number): void {
public deregisterLinkMatcher(matcherId: number): void {
throw new Error('Method not implemented.');
}
registerLinkProvider(linkProvider: ILinkProvider): IDisposable {
public registerLinkProvider(linkProvider: ILinkProvider): IDisposable {
throw new Error('Method not implemented.');
}
hasSelection(): boolean {
public hasSelection(): boolean {
throw new Error('Method not implemented.');
}
getSelection(): string {
public getSelection(): string {
throw new Error('Method not implemented.');
}
getSelectionPosition(): ISelectionPosition | undefined {
public getSelectionPosition(): ISelectionPosition | undefined {
throw new Error('Method not implemented.');
}
clearSelection(): void {
public clearSelection(): void {
throw new Error('Method not implemented.');
}
select(column: number, row: number, length: number): void {
public select(column: number, row: number, length: number): void {
throw new Error('Method not implemented.');
}
selectAll(): void {
public selectAll(): void {
throw new Error('Method not implemented.');
}
dispose(): void {
public dispose(): void {
throw new Error('Method not implemented.');
}
scrollPages(pageCount: number): void {
public scrollPages(pageCount: number): void {
throw new Error('Method not implemented.');
}
scrollToTop(): void {
public scrollToTop(): void {
throw new Error('Method not implemented.');
}
scrollToBottom(): void {
public scrollToBottom(): void {
throw new Error('Method not implemented.');
}
clear(): void {
public clear(): void {
throw new Error('Method not implemented.');
}
write(data: string): void {
public write(data: string): void {
throw new Error('Method not implemented.');
}
writeUtf8(data: Uint8Array): void {
public writeUtf8(data: Uint8Array): void {
throw new Error('Method not implemented.');
}
bracketedPasteMode: boolean;
renderer: IRenderer;
linkifier: ILinkifier;
linkifier2: ILinkifier2;
isFocused: boolean;
options: ITerminalOptions = {};
element: HTMLElement;
screenElement: HTMLElement;
rowContainer: HTMLElement;
selectionContainer: HTMLElement;
selectionService: ISelectionService;
textarea: HTMLTextAreaElement;
rows: number;
cols: number;
browser: IBrowser = <any>Browser;
writeBuffer: string[];
children: HTMLElement[];
cursorHidden: boolean;
cursorState: number;
scrollback: number;
buffers: IBufferSet;
buffer: IBuffer;
viewport: IViewport;
applicationCursor: boolean;
handler(data: string): void {
public bracketedPasteMode: boolean;
public renderer: IRenderer;
public linkifier: ILinkifier;
public linkifier2: ILinkifier2;
public isFocused: boolean;
public options: ITerminalOptions = {};
public element: HTMLElement;
public screenElement: HTMLElement;
public rowContainer: HTMLElement;
public selectionContainer: HTMLElement;
public selectionService: ISelectionService;
public textarea: HTMLTextAreaElement;
public rows: number;
public cols: number;
public browser: IBrowser = <any>Browser;
public writeBuffer: string[];
public children: HTMLElement[];
public cursorHidden: boolean;
public cursorState: number;
public scrollback: number;
public buffers: IBufferSet;
public buffer: IBuffer;
public viewport: IViewport;
public applicationCursor: boolean;
public handler(data: string): void {
throw new Error('Method not implemented.');
}
on(event: string, callback: (...args: any[]) => void): void {
public on(event: string, callback: (...args: any[]) => void): void {
throw new Error('Method not implemented.');
}
off(type: string, listener: XtermListener): void {
public off(type: string, listener: XtermListener): void {
throw new Error('Method not implemented.');
}
addDisposableListener(type: string, handler: XtermListener): IDisposable {
public addDisposableListener(type: string, handler: XtermListener): IDisposable {
throw new Error('Method not implemented.');
}
scrollLines(disp: number, suppressScrollEvent: boolean): void {
public scrollLines(disp: number, suppressScrollEvent: boolean): void {
throw new Error('Method not implemented.');
}
scrollToRow(absoluteRow: number): number {
public scrollToRow(absoluteRow: number): number {
throw new Error('Method not implemented.');
}
cancel(ev: Event, force?: boolean): void {
public cancel(ev: Event, force?: boolean): void {
throw new Error('Method not implemented.');
}
log(text: string): void {
public log(text: string): void {
throw new Error('Method not implemented.');
}
emit(event: string, data: any): void {
public emit(event: string, data: any): void {
throw new Error('Method not implemented.');
}
reset(): void {
public reset(): void {
throw new Error('Method not implemented.');
}
showCursor(): void {
public showCursor(): void {
throw new Error('Method not implemented.');
}
refresh(start: number, end: number): void {
public refresh(start: number, end: number): void {
throw new Error('Method not implemented.');
}
registerCharacterJoiner(handler: CharacterJoinerHandler): number { return 0; }
deregisterCharacterJoiner(joinerId: number): void { }
public registerCharacterJoiner(handler: CharacterJoinerHandler): number { return 0; }
public deregisterCharacterJoiner(joinerId: number): void { }
}
export class MockInputHandlingTerminal implements IInputHandlingTerminal {
onA11yCharEmitter: EventEmitter<string>;
onA11yTabEmitter: EventEmitter<number>;
insertMode: boolean;
bracketedPasteMode: boolean;
sendFocus: boolean;
buffers: IBufferSet;
buffer: IBuffer = new MockBuffer();
viewport: IViewport;
scroll(eraseAttr: IAttributeData, isWrapped?: boolean): void {
public onA11yCharEmitter: EventEmitter<string>;
public onA11yTabEmitter: EventEmitter<number>;
public insertMode: boolean;
public bracketedPasteMode: boolean;
public sendFocus: boolean;
public buffers: IBufferSet;
public buffer: IBuffer = new MockBuffer();
public viewport: IViewport;
public scroll(eraseAttr: IAttributeData, isWrapped?: boolean): void {
throw new Error('Method not implemented.');
}
is(term: string): boolean {
public is(term: string): boolean {
throw new Error('Method not implemented.');
}
resize(x: number, y: number): void {
public resize(x: number, y: number): void {
throw new Error('Method not implemented.');
}
showCursor(): void {
public showCursor(): void {
throw new Error('Method not implemented.');
}
handler(data: string): void {
public handler(data: string): void {
throw new Error('Method not implemented.');
}
handleTitle(title: string): void {
public handleTitle(title: string): void {
throw new Error('Method not implemented.');
}
}
export class MockBuffer implements IBuffer {
markers: IMarker[];
addMarker(y: number): IMarker {
public markers: IMarker[];
public addMarker(y: number): IMarker {
throw new Error('Method not implemented.');
}
isCursorInViewport: boolean;
lines: ICircularList<IBufferLine>;
ydisp: number;
ybase: number;
hasScrollback: boolean;
y: number;
x: number;
tabs: any;
scrollBottom: number;
scrollTop: number;
savedY: number;
savedX: number;
savedCharset: ICharset | null;
savedCurAttrData = new AttributeData();
translateBufferLineToString(lineIndex: number, trimRight: boolean, startCol?: number, endCol?: number): string {
public isCursorInViewport: boolean;
public lines: ICircularList<IBufferLine>;
public ydisp: number;
public ybase: number;
public hasScrollback: boolean;
public y: number;
public x: number;
public tabs: any;
public scrollBottom: number;
public scrollTop: number;
public savedY: number;
public savedX: number;
public savedCharset: ICharset | null;
public savedCurAttrData = new AttributeData();
public translateBufferLineToString(lineIndex: number, trimRight: boolean, startCol?: number, endCol?: number): string {
return Buffer.prototype.translateBufferLineToString.apply(this, arguments);
}
getWrappedRangeForLine(y: number): { first: number, last: number } {
public getWrappedRangeForLine(y: number): { first: number, last: number } {
return Buffer.prototype.getWrappedRangeForLine.apply(this, arguments);
}
nextStop(x?: number): number {
public nextStop(x?: number): number {
throw new Error('Method not implemented.');
}
prevStop(x?: number): number {
public prevStop(x?: number): number {
throw new Error('Method not implemented.');
}
setLines(lines: ICircularList<IBufferLine>): void {
public setLines(lines: ICircularList<IBufferLine>): void {
this.lines = lines;
}
getBlankLine(attr: IAttributeData, isWrapped?: boolean): IBufferLine {
public getBlankLine(attr: IAttributeData, isWrapped?: boolean): IBufferLine {
return Buffer.prototype.getBlankLine.apply(this, arguments);
}
stringIndexToBufferIndex(lineIndex: number, stringIndex: number): number[] {
public stringIndexToBufferIndex(lineIndex: number, stringIndex: number): number[] {
return Buffer.prototype.stringIndexToBufferIndex.apply(this, arguments);
}
iterator(trimRight: boolean, startIndex?: number, endIndex?: number): IBufferStringIterator {
public iterator(trimRight: boolean, startIndex?: number, endIndex?: number): IBufferStringIterator {
return Buffer.prototype.iterator.apply(this, arguments);
}
getNullCell(attr?: IAttributeData): ICellData {
public getNullCell(attr?: IAttributeData): ICellData {
throw new Error('Method not implemented.');
}
getWhitespaceCell(attr?: IAttributeData): ICellData {
public getWhitespaceCell(attr?: IAttributeData): ICellData {
throw new Error('Method not implemented.');
}
}
export class MockRenderer implements IRenderer {
onRequestRefreshRows: IEvent<IRequestRefreshRowsEvent>;
onCanvasResize: IEvent<{ width: number, height: number }>;
onRender: IEvent<{ start: number, end: number }>;
dispose(): void {
public onRequestRefreshRows: IEvent<IRequestRefreshRowsEvent>;
public onCanvasResize: IEvent<{ width: number, height: number }>;
public onRender: IEvent<{ start: number, end: number }>;
public dispose(): void {
throw new Error('Method not implemented.');
}
colorManager: IColorManager;
on(type: string, listener: XtermListener): void {
public colorManager: IColorManager;
public on(type: string, listener: XtermListener): void {
throw new Error('Method not implemented.');
}
off(type: string, listener: XtermListener): void {
public off(type: string, listener: XtermListener): void {
throw new Error('Method not implemented.');
}
emit(type: string, data?: any): void {
public emit(type: string, data?: any): void {
throw new Error('Method not implemented.');
}
addDisposableListener(type: string, handler: XtermListener): IDisposable {
public addDisposableListener(type: string, handler: XtermListener): IDisposable {
throw new Error('Method not implemented.');
}
dimensions: IRenderDimensions;
setColors(colors: IColorSet): void {
public dimensions: IRenderDimensions;
public setColors(colors: IColorSet): void {
throw new Error('Method not implemented.');
}
onResize(cols: number, rows: number): void { }
onCharSizeChanged(): void { }
onBlur(): void { }
onFocus(): void { }
onSelectionChanged(start: [number, number], end: [number, number]): void { }
onCursorMove(): void { }
onOptionsChanged(): void { }
onDevicePixelRatioChange(): void { }
clear(): void { }
renderRows(start: number, end: number): void { }
registerCharacterJoiner(handler: CharacterJoinerHandler): number { return 0; }
deregisterCharacterJoiner(): boolean { return true; }
public onResize(cols: number, rows: number): void { }
public onCharSizeChanged(): void { }
public onBlur(): void { }
public onFocus(): void { }
public onSelectionChanged(start: [number, number], end: [number, number]): void { }
public onCursorMove(): void { }
public onOptionsChanged(): void { }
public onDevicePixelRatioChange(): void { }
public clear(): void { }
public renderRows(start: number, end: number): void { }
public registerCharacterJoiner(handler: CharacterJoinerHandler): number { return 0; }
public deregisterCharacterJoiner(): boolean { return true; }
}
export class MockViewport implements IViewport {
dispose(): void {
public dispose(): void {
throw new Error('Method not implemented.');
}
scrollBarWidth: number = 0;
onThemeChange(colors: IColorSet): void {
public scrollBarWidth: number = 0;
public onThemeChange(colors: IColorSet): void {
throw new Error('Method not implemented.');
}
onWheel(ev: WheelEvent): boolean {
public onWheel(ev: WheelEvent): boolean {
throw new Error('Method not implemented.');
}
onTouchStart(ev: TouchEvent): void {
public onTouchStart(ev: TouchEvent): void {
throw new Error('Method not implemented.');
}
onTouchMove(ev: TouchEvent): boolean {
public onTouchMove(ev: TouchEvent): boolean {
throw new Error('Method not implemented.');
}
syncScrollArea(): void { }
getLinesScrolled(ev: WheelEvent): number {
public syncScrollArea(): void { }
public getLinesScrolled(ev: WheelEvent): number {
throw new Error('Method not implemented.');
}
}
export class MockCompositionHelper implements ICompositionHelper {
compositionstart(): void {
public compositionstart(): void {
throw new Error('Method not implemented.');
}
compositionupdate(ev: CompositionEvent): void {
public compositionupdate(ev: CompositionEvent): void {
throw new Error('Method not implemented.');
}
compositionend(): void {
public compositionend(): void {
throw new Error('Method not implemented.');
}
updateCompositionElements(dontRecurse?: boolean): void {
public updateCompositionElements(dontRecurse?: boolean): void {
throw new Error('Method not implemented.');
}
keydown(ev: KeyboardEvent): boolean {
public keydown(ev: KeyboardEvent): boolean {
return true;
}
}