typescript-closure-tools

// Type definitions for Ace Ajax.org Cloud9 Editor // Project: http://ace.ajax.org/ // Definitions by: Diullei Gomes <https://github.com/Diullei> // Definitions: https://github.com/borisyankov/DefinitelyTyped declare module AceAjax { export interface Delta { action: string; range: Range; text: string; lines: string[]; } export interface EditorCommand { name:string; bindKey:any; exec:Function; } export interface CommandManager { byName; commands; platform: string; addCommands(commands:EditorCommand[]); addCommand(command:EditorCommand); exec(name: string, editor: Editor, args: any); } export interface Annotation { row: number; column: number; text: string; type: string; } export interface TokenInfo { value: string; } export interface Position { row: number; column: number; } export interface KeyBinding { setDefaultHandler(kb); setKeyboardHandler(kb); addKeyboardHandler(kb, pos); removeKeyboardHandler(kb): boolean; getKeyboardHandler(): any; onCommandKey(e, hashId, keyCode); onTextInput(text); } var KeyBinding: { new(editor: Editor): KeyBinding; } export interface TextMode { getTokenizer(): any; toggleCommentLines(state, doc, startRow, endRow); getNextLineIndent (state, line, tab): string; checkOutdent(state, line, input): boolean; autoOutdent(state, doc, row); createWorker(session): any; createModeDelegates (mapping); transformAction(state, action, editor, session, param): any; } //////////////// /// Ace //////////////// /** * The main class required to set up an Ace instance in the browser. **/ export interface Ace { /** * Provides access to require in packed noconflict mode * @param moduleName **/ require(moduleName: string): any; /** * Embeds the Ace editor into the DOM, at the element provided by `el`. * @param el Either the id of an element, or the element itself **/ edit(el: string): Editor; /** * Embeds the Ace editor into the DOM, at the element provided by `el`. * @param el Either the id of an element, or the element itself **/ edit(el: HTMLElement): Editor; /** * Creates a new [[EditSession]], and returns the associated [[Document]]. * @param text {:textParam} * @param mode {:modeParam} **/ createEditSession(text: Document, mode: TextMode): IEditSession; /** * Creates a new [[EditSession]], and returns the associated [[Document]]. * @param text {:textParam} * @param mode {:modeParam} **/ createEditSession(text: string, mode: TextMode): IEditSession; } //////////////// /// Anchor //////////////// /** * Defines the floating pointer in the document. Whenever text is inserted or deleted before the cursor, the position of the cursor is updated. **/ export interface Anchor { on(event: string, fn: (e) => any); /** * Returns an object identifying the `row` and `column` position of the current anchor. **/ getPosition(): Position; /** * Returns the current document. **/ getDocument(): Document; /** * Fires whenever the anchor position changes. * Both of these objects have a `row` and `column` property corresponding to the position. * Events that can trigger this function include [[Anchor.setPosition `setPosition()`]]. * @param e An object containing information about the anchor position. It has two properties: * - `old`: An object describing the old Anchor position * - `value`: An object describing the new Anchor position **/ onChange(e: any); /** * Sets the anchor position to the specified row and column. If `noClip` is `true`, the position is not clipped. * @param row The row index to move the anchor to * @param column The column index to move the anchor to * @param noClip Identifies if you want the position to be clipped **/ setPosition(row: number, column: number, noClip: boolean); /** * When called, the `'change'` event listener is removed. **/ detach(); } var Anchor: { /** * Creates a new `Anchor` and associates it with a document. * @param doc The document to associate with the anchor * @param row The starting row position * @param column The starting column position **/ new(doc: Document, row: number, column: number): Anchor; } //////////////////////////////// /// BackgroundTokenizer //////////////////////////////// /** * Tokenizes the current [[Document `Document`]] in the background, and caches the tokenized rows for future use. * If a certain row is changed, everything below that row is re-tokenized. **/ export interface BackgroundTokenizer { states: any[]; /** * Sets a new tokenizer for this object. * @param tokenizer The new tokenizer to use **/ setTokenizer(tokenizer: Tokenizer); /** * Sets a new document to associate with this object. * @param doc The new document to associate with **/ setDocument(doc: Document); /** * Emits the `'update'` event. `firstRow` and `lastRow` are used to define the boundaries of the region to be updated. * @param firstRow The starting row region * @param lastRow The final row region **/ fireUpdateEvent(firstRow: number, lastRow: number); /** * Starts tokenizing at the row indicated. * @param startRow The row to start at **/ start(startRow: number); /** * Stops tokenizing. **/ stop(); /** * Gives list of tokens of the row. (tokens are cached) * @param row The row to get tokens at **/ getTokens(row: number): TokenInfo[]; /** * [Returns the state of tokenization at the end of a row.]{: #BackgroundTokenizer.getState} * @param row The row to get state at **/ getState(row: number): string; } var BackgroundTokenizer: { /** * Creates a new `BackgroundTokenizer` object. * @param tokenizer The tokenizer to use * @param editor The editor to associate with **/ new(tokenizer: Tokenizer, editor: Editor): BackgroundTokenizer; } //////////////// /// Document //////////////// /** * Contains the text of the document. Document can be attached to several [[EditSession `EditSession`]]s. * At its core, `Document`s are just an array of strings, with each row in the document matching up to the array index. **/ export interface Document { on(event: string, fn: (e) => any); /** * Replaces all the lines in the current `Document` with the value of `text`. * @param text The text to use **/ setValue(text: string); /** * Returns all the lines in the document as a single string, split by the new line character. **/ getValue(): string; /** * Creates a new `Anchor` to define a floating point in the document. * @param row The row number to use * @param column The column number to use **/ createAnchor(row: number, column: number); /** * Returns the newline character that's being used, depending on the value of `newLineMode`. **/ getNewLineCharacter(): string; /** * [Sets the new line mode.]{: #Document.setNewLineMode.desc} * @param newLineMode [The newline mode to use; can be either `windows`, `unix`, or `auto`]{: #Document.setNewLineMode.param} **/ setNewLineMode(newLineMode: string); /** * [Returns the type of newlines being used; either `windows`, `unix`, or `auto`]{: #Document.getNewLineMode} **/ getNewLineMode(): string; /** * Returns `true` if `text` is a newline character (either `\r\n`, `\r`, or `\n`). * @param text The text to check **/ isNewLine(text: string): boolean; /** * Returns a verbatim copy of the given line as it is in the document * @param row The row index to retrieve **/ getLine(row: number): string; /** * Returns an array of strings of the rows between `firstRow` and `lastRow`. This function is inclusive of `lastRow`. * @param firstRow The first row index to retrieve * @param lastRow The final row index to retrieve **/ getLines(firstRow: number, lastRow: number): string[]; /** * Returns all lines in the document as string array. Warning: The caller should not modify this array! **/ getAllLines(): string[]; /** * Returns the number of rows in the document. **/ getLength(): number; /** * [Given a range within the document, this function returns all the text within that range as a single string.]{: #Document.getTextRange.desc} * @param range The range to work with **/ getTextRange(range: Range): string; /** * Inserts a block of `text` and the indicated `position`. * @param position The position to start inserting at * @param text A chunk of text to insert **/ insert(position: Position, text: string): any; /** * Inserts the elements in `lines` into the document, starting at the row index given by `row`. This method also triggers the `'change'` event. * @param row The index of the row to insert at * @param lines An array of strings **/ insertLines(row: number, lines: string[]): any; /** * Inserts a new line into the document at the current row's `position`. This method also triggers the `'change'` event. * @param position The position to insert at **/ insertNewLine(position: Position): any; /** * Inserts `text` into the `position` at the current row. This method also triggers the `'change'` event. * @param position The position to insert at * @param text A chunk of text **/ insertInLine(position: any, text: string): any; /** * Removes the `range` from the document. * @param range A specified Range to remove **/ remove(range: Range): any; /** * Removes the specified columns from the `row`. This method also triggers the `'change'` event. * @param row The row to remove from * @param startColumn The column to start removing at * @param endColumn The column to stop removing at **/ removeInLine(row: number, startColumn: number, endColumn: number): any; /** * Removes a range of full lines. This method also triggers the `'change'` event. * @param firstRow The first row to be removed * @param lastRow The last row to be removed **/ removeLines(firstRow: number, lastRow: number): string[]; /** * Removes the new line between `row` and the row immediately following it. This method also triggers the `'change'` event. * @param row The row to check **/ removeNewLine(row: number); /** * Replaces a range in the document with the new `text`. * @param range A specified Range to replace * @param text The new text to use as a replacement **/ replace(range: Range, text: string): any; /** * Applies all the changes previously accumulated. These can be either `'includeText'`, `'insertLines'`, `'removeText'`, and `'removeLines'`. **/ applyDeltas(deltas: Delta[]); /** * Reverts any changes previously applied. These can be either `'includeText'`, `'insertLines'`, `'removeText'`, and `'removeLines'`. **/ revertDeltas(deltas: Delta[]); /** * Converts an index position in a document to a `{row, column}` object. * Index refers to the "absolute position" of a character in the document. For example: * ```javascript * var x = 0; // 10 characters, plus one for newline * var y = -1; * ``` * Here, `y` is an index 15: 11 characters for the first row, and 5 characters until `y` in the second. * @param index An index to convert * @param startRow=0 The row from which to start the conversion **/ indexToPosition(index: number, startRow: number): Position; /** * Converts the `{row, column}` position in a document to the character's index. * Index refers to the "absolute position" of a character in the document. For example: * ```javascript * var x = 0; // 10 characters, plus one for newline * var y = -1; * ``` * Here, `y` is an index 15: 11 characters for the first row, and 5 characters until `y` in the second. * @param pos The `{row, column}` to convert * @param startRow=0 The row from which to start the conversion **/ positionToIndex(pos: Position, startRow: number): number; } var Document: { /** * Creates a new `Document`. If `text` is included, the `Document` contains those strings; otherwise, it's empty. * @param text The starting text **/ new(text?: string): Document; /** * Creates a new `Document`. If `text` is included, the `Document` contains those strings; otherwise, it's empty. * @param text The starting text **/ new(text?: string[]): Document; } //////////////////////////////// /// EditSession //////////////////////////////// /** * Stores all the data about [[Editor `Editor`]] state providing easy way to change editors state. * `EditSession` can be attached to only one [[Document `Document`]]. Same `Document` can be attached to several `EditSession`s. **/ export interface IEditSession { selection: Selection; bgTokenizer: BackgroundTokenizer; doc: Document; on(event: string, fn: (e) => any); findMatchingBracket(position: Position); addFold(text: string, range: Range); getFoldAt(row: number, column: number): any; removeFold(arg: any); expandFold(arg: any); unfold(arg1: any, arg2: boolean); screenToDocumentColumn(row: number, column: number); getFoldDisplayLine(foldLine: any, docRow: number, docColumn: number): any; getFoldsInRange(range: Range): any; highlight(text: string); /** * Sets the `EditSession` to point to a new `Document`. If a `BackgroundTokenizer` exists, it also points to `doc`. * @param doc The new `Document` to use **/ setDocument(doc: Document); /** * Returns the `Document` associated with this session. **/ getDocument(): Document; /** * undefined * @param row The row to work with **/ $resetRowCache(row: number); /** * Sets the session text. * @param text The new text to place **/ setValue(text: string); setMode(mode: string); /** * Returns the current [[Document `Document`]] as a string. **/ getValue(): string; /** * Returns the string of the current selection. **/ getSelection(): Selection; /** * {:BackgroundTokenizer.getState} * @param row The row to start at **/ getState(row: number): string; /** * Starts tokenizing at the row indicated. Returns a list of objects of the tokenized rows. * @param row The row to start at **/ getTokens(row: number): TokenInfo[]; /** * Returns an object indicating the token at the current row. The object has two properties: `index` and `start`. * @param row The row number to retrieve from * @param column The column number to retrieve from **/ getTokenAt(row: number, column: number): TokenInfo; /** * Sets the undo manager. * @param undoManager The new undo manager **/ setUndoManager(undoManager: UndoManager); /** * Returns the current undo manager. **/ getUndoManager(): UndoManager; /** * Returns the current value for tabs. If the user is using soft tabs, this will be a series of spaces (defined by [[EditSession.getTabSize `getTabSize()`]]); otherwise it's simply `'\t'`. **/ getTabString(): string; /** * Pass `true` to enable the use of soft tabs. Soft tabs means you're using spaces instead of the tab character (`'\t'`). * @param useSoftTabs Value indicating whether or not to use soft tabs **/ setUseSoftTabs(useSoftTabs: boolean); /** * Returns `true` if soft tabs are being used, `false` otherwise. **/ getUseSoftTabs(): boolean; /** * Set the number of spaces that define a soft tab; for example, passing in `4` transforms the soft tabs to be equivalent to four spaces. This function also emits the `changeTabSize` event. * @param tabSize The new tab size **/ setTabSize(tabSize: number); /** * Returns the current tab size. **/ getTabSize(): string; /** * Returns `true` if the character at the position is a soft tab. * @param position The position to check **/ isTabStop(position: any): boolean; /** * Pass in `true` to enable overwrites in your session, or `false` to disable. * If overwrites is enabled, any text you enter will type over any text after it. If the value of `overwrite` changes, this function also emites the `changeOverwrite` event. * @param overwrite Defines wheter or not to set overwrites **/ setOverwrite(overwrite: boolean); /** * Returns `true` if overwrites are enabled; `false` otherwise. **/ getOverwrite(): boolean; /** * Sets the value of overwrite to the opposite of whatever it currently is. **/ toggleOverwrite(); /** * Adds `className` to the `row`, to be used for CSS stylings and whatnot. * @param row The row number * @param className The class to add **/ addGutterDecoration(row: number, className: string); /** * Removes `className` from the `row`. * @param row The row number * @param className The class to add **/ removeGutterDecoration(row: number, className: string); /** * Returns an array of numbers, indicating which rows have breakpoints. **/ getBreakpoints(): number[]; /** * Sets a breakpoint on every row number given by `rows`. This function also emites the `'changeBreakpoint'` event. * @param rows An array of row indices **/ setBreakpoints(rows: any[]); /** * Removes all breakpoints on the rows. This function also emites the `'changeBreakpoint'` event. **/ clearBreakpoints(); /** * Sets a breakpoint on the row number given by `rows`. This function also emites the `'changeBreakpoint'` event. * @param row A row index * @param className Class of the breakpoint **/ setBreakpoint(row: number, className: string); /** * Removes a breakpoint on the row number given by `rows`. This function also emites the `'changeBreakpoint'` event. * @param row A row index **/ clearBreakpoint(row: number); /** * Adds a new marker to the given `Range`. If `inFront` is `true`, a front marker is defined, and the `'changeFrontMarker'` event fires; otherwise, the `'changeBackMarker'` event fires. * @param range Define the range of the marker * @param clazz Set the CSS class for the marker * @param type Identify the type of the marker * @param inFront Set to `true` to establish a front marker **/ addMarker(range: Range, clazz: string, type: Function, inFront: boolean); /** * Adds a new marker to the given `Range`. If `inFront` is `true`, a front marker is defined, and the `'changeFrontMarker'` event fires; otherwise, the `'changeBackMarker'` event fires. * @param range Define the range of the marker * @param clazz Set the CSS class for the marker * @param type Identify the type of the marker * @param inFront Set to `true` to establish a front marker **/ addMarker(range: Range, clazz: string, type: string, inFront: boolean); /** * Adds a dynamic marker to the session. * @param marker object with update method * @param inFront Set to `true` to establish a front marker **/ addDynamicMarker(marker: any, inFront: boolean); /** * Removes the marker with the specified ID. If this marker was in front, the `'changeFrontMarker'` event is emitted. If the marker was in the back, the `'changeBackMarker'` event is emitted. * @param markerId A number representing a marker **/ removeMarker(markerId: number); /** * Returns an array containing the IDs of all the markers, either front or back. * @param inFront If `true`, indicates you only want front markers; `false` indicates only back markers **/ getMarkers(inFront: boolean): any[]; /** * Sets annotations for the `EditSession`. This functions emits the `'changeAnnotation'` event. * @param annotations A list of annotations **/ setAnnotations(annotations: Annotation[]); /** * Returns the annotations for the `EditSession`. **/ getAnnotations(): any; /** * Clears all the annotations for this session. This function also triggers the `'changeAnnotation'` event. **/ clearAnnotations(); /** * If `text` contains either the newline (`\n`) or carriage-return ('\r') characters, `$autoNewLine` stores that value. * @param text A block of text **/ $detectNewLine(text: string); /** * Given a starting row and column, this method returns the `Range` of the first word boundary it finds. * @param row The row to start at * @param column The column to start at **/ getWordRange(row: number, column: number): Range; /** * Gets the range of a word, including its right whitespace. * @param row The row number to start from * @param column The column number to start from **/ getAWordRange(row: number, column: number): any; /** * {:Document.setNewLineMode.desc} * @param newLineMode {:Document.setNewLineMode.param} **/ setNewLineMode(newLineMode: string); /** * Returns the current new line mode. **/ getNewLineMode(): string; /** * Identifies if you want to use a worker for the `EditSession`. * @param useWorker Set to `true` to use a worker **/ setUseWorker(useWorker: boolean); /** * Returns `true` if workers are being used. **/ getUseWorker(): boolean; /** * Reloads all the tokens on the current session. This function calls [[BackgroundTokenizer.start `BackgroundTokenizer.start ()`]] to all the rows; it also emits the `'tokenizerUpdate'` event. **/ onReloadTokenizer(); /** * Sets a new text mode for the `EditSession`. This method also emits the `'changeMode'` event. If a [[BackgroundTokenizer `BackgroundTokenizer`]] is set, the `'tokenizerUpdate'` event is also emitted. * @param mode Set a new text mode **/ $mode(mode: TextMode); /** * Returns the current text mode. **/ getMode(): TextMode; /** * This function sets the scroll top value. It also emits the `'changeScrollTop'` event. * @param scrollTop The new scroll top value **/ setScrollTop(scrollTop: number); /** * [Returns the value of the distance between the top of the editor and the topmost part of the visible content.]{: #EditSession.getScrollTop} **/ getScrollTop(): number; /** * [Sets the value of the distance between the left of the editor and the leftmost part of the visible content.]{: #EditSession.setScrollLeft} **/ setScrollLeft(); /** * [Returns the value of the distance between the left of the editor and the leftmost part of the visible content.]{: #EditSession.getScrollLeft} **/ getScrollLeft(): number; /** * Returns the width of the screen. **/ getScreenWidth(): number; /** * Returns a verbatim copy of the given line as it is in the document * @param row The row to retrieve from **/ getLine(row: number): string; /** * Returns an array of strings of the rows between `firstRow` and `lastRow`. This function is inclusive of `lastRow`. * @param firstRow The first row index to retrieve * @param lastRow The final row index to retrieve **/ getLines(firstRow: number, lastRow: number): string[]; /** * Returns the number of rows in the document. **/ getLength(): number; /** * {:Document.getTextRange.desc} * @param range The range to work with **/ getTextRange(range: Range): string; /** * Inserts a block of `text` and the indicated `position`. * @param position The position {row, column} to start inserting at * @param text A chunk of text to insert **/ insert(position: Position, text: string): any; /** * Removes the `range` from the document. * @param range A specified Range to remove **/ remove(range: Range): any; /** * Reverts previous changes to your document. * @param deltas An array of previous changes * @param dontSelect [If `true`, doesn't select the range of where the change occured]{: #dontSelect} **/ undoChanges(deltas: any[], dontSelect: boolean): Range; /** * Re-implements a previously undone change to your document. * @param deltas An array of previous changes * @param dontSelect {:dontSelect} **/ redoChanges(deltas: any[], dontSelect: boolean): Range; /** * Enables or disables highlighting of the range where an undo occured. * @param enable If `true`, selects the range of the reinserted change **/ setUndoSelect(enable: boolean); /** * Replaces a range in the document with the new `text`. * @param range A specified Range to replace * @param text The new text to use as a replacement **/ replace(range: Range, text: string): any; /** * Moves a range of text from the given range to the given position. `toPosition` is an object that looks like this: * ```json * { row: newRowLocation, column: newColumnLocation } * ``` * @param fromRange The range of text you want moved within the document * @param toPosition The location (row and column) where you want to move the text to **/ moveText(fromRange: Range, toPosition: any): Range; /** * Indents all the rows, from `startRow` to `endRow` (inclusive), by prefixing each row with the token in `indentString`. * If `indentString` contains the `'\t'` character, it's replaced by whatever is defined by [[EditSession.getTabString `getTabString()`]]. * @param startRow Starting row * @param endRow Ending row * @param indentString The indent token **/ indentRows(startRow: number, endRow: number, indentString: string); /** * Outdents all the rows defined by the `start` and `end` properties of `range`. * @param range A range of rows **/ outdentRows(range: Range); /** * Shifts all the lines in the document up one, starting from `firstRow` and ending at `lastRow`. * @param firstRow The starting row to move up * @param lastRow The final row to move up **/ moveLinesUp(firstRow: number, lastRow: number): number; /** * Shifts all the lines in the document down one, starting from `firstRow` and ending at `lastRow`. * @param firstRow The starting row to move down * @param lastRow The final row to move down **/ moveLinesDown(firstRow: number, lastRow: number): number; /** * Duplicates all the text between `firstRow` and `lastRow`. * @param firstRow The starting row to duplicate * @param lastRow The final row to duplicate **/ duplicateLines(firstRow: number, lastRow: number): number; /** * Sets whether or not line wrapping is enabled. If `useWrapMode` is different than the current value, the `'changeWrapMode'` event is emitted. * @param useWrapMode Enable (or disable) wrap mode **/ setUseWrapMode(useWrapMode: boolean); /** * Returns `true` if wrap mode is being used; `false` otherwise. **/ getUseWrapMode(): boolean; /** * Sets the boundaries of wrap. Either value can be `null` to have an unconstrained wrap, or, they can be the same number to pin the limit. If the wrap limits for `min` or `max` are different, this method also emits the `'changeWrapMode'` event. * @param min The minimum wrap value (the left side wrap) * @param max The maximum wrap value (the right side wrap) **/ setWrapLimitRange(min: number, max: number); /** * This should generally only be called by the renderer when a resize is detected. * @param desiredLimit The new wrap limit **/ adjustWrapLimit(desiredLimit: number): boolean; /** * Returns the value of wrap limit. **/ getWrapLimit(): number; /** * Returns an object that defines the minimum and maximum of the wrap limit; it looks something like this: * { min: wrapLimitRange_min, max: wrapLimitRange_max } **/ getWrapLimitRange(): any; /** * Given a string, returns an array of the display characters, including tabs and spaces. * @param str The string to check * @param offset The value to start at **/ $getDisplayTokens(str: string, offset: number); /** * Calculates the width of the string `str` on the screen while assuming that the string starts at the first column on the screen. * @param str The string to calculate the screen width of * @param maxScreenColumn * @param screenColumn **/ $getStringScreenWidth(str: string, maxScreenColumn: number, screenColumn: number): number[]; /** * Returns number of screenrows in a wrapped line. * @param row The row number to check **/ getRowLength(row: number): number; /** * Returns the position (on screen) for the last character in the provided screen row. * @param screenRow The screen row to check **/ getScreenLastRowColumn(screenRow: number): number; /** * For the given document row and column, this returns the column position of the last screen row. * @param docRow * @param docColumn **/ getDocumentLastRowColumn(docRow: number, docColumn: number): number; /** * For the given document row and column, this returns the document position of the last row. * @param docRow * @param docColumn **/ getDocumentLastRowColumnPosition(docRow: number, docColumn: number): number; /** * For the given row, this returns the split data. **/ getRowSplitData(): string; /** * The distance to the next tab stop at the specified screen column. * @param screenColumn The screen column to check **/ getScreenTabSize(screenColumn: number): number; /** * Converts characters coordinates on the screen to characters coordinates within the document. [This takes into account code folding, word wrap, tab size, and any other visual modifications.]{: #conversionConsiderations} * @param screenRow The screen row to check * @param screenColumn The screen column to check **/ screenToDocumentPosition(screenRow: number, screenColumn: number): any; /** * Converts document coordinates to screen coordinates. {:conversionConsiderations} * @param docRow The document row to check * @param docColumn The document column to check **/ documentToScreenPosition(docRow: number, docColumn: number): any; /** * For the given document row and column, returns the screen column. * @param row * @param docColumn **/ documentToScreenColumn(row: number, docColumn: number): number; /** * For the given document row and column, returns the screen row. * @param docRow * @param docColumn **/ documentToScreenRow(docRow: number, docColumn: number); /** * Returns the length of the screen. **/ getScreenLength(): number; } var EditSession: { /** * Sets up a new `EditSession` and associates it with the given `Document` and `TextMode`. * @param text [If `text` is a `Document`, it associates the `EditSession` with it. Otherwise, a new `Document` is created, with the initial text]{: #textParam} * @param mode [The inital language mode to use for the document]{: #modeParam} **/ new(text: string, mode?: TextMode): IEditSession; new(content: string, mode?: string): IEditSession; new (text: string[], mode?: string): IEditSession; } //////////////////////////////// /// Editor //////////////////////////////// /** * The main entry point into the Ace functionality. * The `Editor` manages the [[EditSession]] (which manages [[Document]]s), as well as the [[VirtualRenderer]], which draws everything to the screen. * Event sessions dealing with the mouse and keyboard are bubbled up from `Document` to the `Editor`, which decides what to do with them. **/ export interface Editor { inMultiSelectMode: boolean; selectMoreLines(n: number); onTextInput(text: string); onCommandKey(e, hashId, keyCode); commands: CommandManager; session: IEditSession; selection: Selection; renderer: VirtualRenderer; keyBinding: KeyBinding; container: HTMLElement; onSelectionChange(e); onChangeMode(e?); execCommand(command:string, args?: any); /** * Sets a new key handler, such as "vim" or "windows". * @param keyboardHandler The new key handler **/ setKeyboardHandler(keyboardHandler: string); /** * Returns the keyboard handler, such as "vim" or "windows". **/ getKeyboardHandler(): string; /** * Sets a new editsession to use. This method also emits the `'changeSession'` event. * @param session The new session to use **/ setSession(session: IEditSession); /** * Returns the current session being used. **/ getSession(): IEditSession; /** * Sets the current document to `val`. * @param val The new value to set for the document * @param cursorPos Where to set the new value. `undefined` or 0 is selectAll, -1 is at the document start, and 1 is at the end **/ setValue(val: string, cursorPos?: number): string; /** * Returns the current session's content. **/ getValue(): string; /** * Returns the currently highlighted selection. **/ getSelection(): Selection; /** * {:VirtualRenderer.onResize} * @param force If `true`, recomputes the size, even if the height and width haven't changed **/ resize(force?: boolean); /** * {:VirtualRenderer.setTheme} * @param theme The path to a theme **/ setTheme(theme: string); /** * {:VirtualRenderer.getTheme} **/ getTheme(): string; /** * {:VirtualRenderer.setStyle} * @param style A class name **/ setStyle(style: string); /** * {:VirtualRenderer.unsetStyle} **/ unsetStyle(); /** * Set a new font size (in pixels) for the editor text. * @param size A font size ( _e.g._ "12px") **/ setFontSize(size: string); /** * Brings the current `textInput` into focus. **/ focus(); /** * Returns `true` if the current `textInput` is in focus. **/ isFocused(); /** * Blurs the current `textInput`. **/ blur(); /** * Emitted once the editor comes into focus. **/ onFocus(); /** * Emitted once the editor has been blurred. **/ onBlur(); /** * Emitted whenever the document is changed. * @param e Contains a single property, `data`, which has the delta of changes **/ onDocumentChange(e: any); /** * Emitted when the selection changes. **/ onCursorChange(); /** * Returns the string of text currently highlighted. **/ getCopyText(): string; /** * Called whenever a text "copy" happens. **/ onCopy(); /** * Called whenever a text "cut" happens. **/ onCut(); /** * Called whenever a text "paste" happens. * @param text The pasted text **/ onPaste(text: string); /** * Inserts `text` into wherever the cursor is pointing. * @param text The new text to add **/ insert(text: string); /** * Pass in `true` to enable overwrites in your session, or `false` to disable. If overwrites is enabled, any text you enter will type over any text after it. If the value of `overwrite` changes, this function also emites the `changeOverwrite` event. * @param overwrite Defines wheter or not to set overwrites **/ setOverwrite(overwrite: boolean); /** * Returns `true` if overwrites are enabled; `false` otherwise. **/ getOverwrite(): boolean; /** * Sets the value of overwrite to the opposite of whatever it currently is. **/ toggleOverwrite(); /** * Sets how fast the mouse scrolling should do. * @param speed A value indicating the new speed (in milliseconds) **/ setScrollSpeed(speed: number); /** * Returns the value indicating how fast the mouse scroll speed is (in milliseconds). **/ getScrollSpeed(): number; /** * Sets the delay (in milliseconds) of the mouse drag. * @param dragDelay A value indicating the new delay **/ setDragDelay(dragDelay: number); /** * Returns the current mouse drag delay. **/ getDragDelay(): number; /** * Indicates how selections should occur. * By default, selections are set to "line". There are no other styles at the moment, * although this code change in the future. * This function also emits the `'changeSelectionStyle'` event. * @param style The new selection style **/ setSelectionStyle(style: string); /** * Returns the current selection style. **/ getSelectionStyle(): string; /** * Determines whether or not the current line should be highlighted. * @param shouldHighlight Set to `true` to highlight the current line **/ setHighlightActiveLine(shouldHighlight: boolean); /** * Returns `true` if current lines are always highlighted. **/ getHighlightActiveLine(); /** * Determines if the currently selected word should be highlighted. * @param shouldHighlight Set to `true` to highlight the currently selected word **/ setHighlightSelectedWord(shouldHighlight: boolean); /** * Returns `true` if currently highlighted words are to be highlighted. **/ getHighlightSelectedWord(): boolean; /** * If `showInvisibiles` is set to `true`, invisible characters—like spaces or new lines—are show in the editor. * @param showInvisibles Specifies whether or not to show invisible characters **/ setShowInvisibles(showInvisibles: boolean); /** * Returns `true` if invisible characters are being shown. **/ getShowInvisibles(): boolean; /** * If `showPrintMargin` is set to `true`, the print margin is shown in the editor. * @param showPrintMargin Specifies whether or not to show the print margin **/ setShowPrintMargin(showPrintMargin: boolean); /** * Returns `true` if the print margin is being shown. **/ getShowPrintMargin(): boolean; /** * Sets the column defining where the print margin should be. * @param showPrintMargin Specifies the new print margin **/ setPrintMarginColumn(showPrintMargin: number); /** * Returns the column number of where the print margin is. **/ getPrintMarginColumn(): number; /** * If `readOnly` is true, then the editor is set to read-only mode, and none of the content can change. * @param readOnly Specifies whether the editor can be modified or not **/ setReadOnly(readOnly: boolean); /** * Returns `true` if the editor is set to read-only mode. **/ getReadOnly(): boolean; /** * Specifies whether to use behaviors or not. ["Behaviors" in this case is the auto-pairing of special characters, like quotation marks, parenthesis, or brackets.]{: #BehaviorsDef} * @param enabled Enables or disables behaviors **/ setBehavioursEnabled(enabled: boolean); /** * Returns `true` if the behaviors are currently enabled. {:BehaviorsDef} **/ getBehavioursEnabled(): boolean; /** * Specifies whether to use wrapping behaviors or not, i.e. automatically wrapping the selection with characters such as brackets * when such a character is typed in. * @param enabled Enables or disables wrapping behaviors **/ setWrapBehavioursEnabled(enabled: boolean); /** * Returns `true` if the wrapping behaviors are currently enabled. **/ getWrapBehavioursEnabled(); /** * Indicates whether the fold widgets are shown or not. * @param show Specifies whether the fold widgets are shown **/ setShowFoldWidgets(show: boolean); /** * Returns `true` if the fold widgets are shown. **/ getShowFoldWidgets(); /** * Removes words of text from the editor. A "word" is defined as a string of characters bookended by whitespace. * @param dir The direction of the deletion to occur, either "left" or "right" **/ remove(dir: string); /** * Removes the word directly to the right of the current selection. **/ removeWordRight(); /** * Removes the word directly to the left of the current selection. **/ removeWordLeft(); /** * Removes all the words to the left of the current selection, until the start of the line. **/ removeToLineStart(); /** * Removes all the words to the right of the current selection, until the end of the line. **/ removeToLineEnd(); /** * Splits the line at the current selection (by inserting an `'\n'`). **/ splitLine(); /** * Transposes current line. **/ transposeLetters(); /** * Converts the current selection entirely into lowercase. **/ toLowerCase(); /** * Converts the current selection entirely into uppercase. **/ toUpperCase(); /** * Inserts an indentation into the current cursor position or indents the selected lines. **/ indent(); /** * Indents the current line. **/ blockIndent(); /** * Outdents the current line. **/ blockOutdent(arg?: string); /** * Given the currently selected range, this function either comments all the lines, or uncomments all of them. **/ toggleCommentLines(); /** * Works like [[EditSession.getTokenAt]], except it returns a number. **/ getNumberAt(): number; /** * If the character before the cursor is a number, this functions changes its value by `amount`. * @param amount The value to change the numeral by (can be negative to decrease value) **/ modifyNumber(amount: number); /** * Removes all the lines in the current selection **/ removeLines(); /** * Shifts all the selected lines down one row. **/ moveLinesDown(): number; /** * Shifts all the selected lines up one row. **/ moveLinesUp(): number; /** * Moves a range of text from the given range to the given position. `toPosition` is an object that looks like this: * ```json * { row: newRowLocation, column: newColumnLocation } * ``` * @param fromRange The range of text you want moved within the document * @param toPosition The location (row and column) where you want to move the text to **/ moveText(fromRange: Range, toPosition: any): Range; /** * Copies all the selected lines up one row. **/ copyLinesUp(): number; /** * Copies all the selected lines down one row. **/ copyLinesDown(): number; /** * {:VirtualRenderer.getFirstVisibleRow} **/ getFirstVisibleRow(): number; /** * {:VirtualRenderer.getLastVisibleRow} **/ getLastVisibleRow(): number; /** * Indicates if the row is currently visible on the screen. * @param row The row to check **/ isRowVisible(row: number): boolean; /** * Indicates if the entire row is currently visible on the screen. * @param row The row to check **/ isRowFullyVisible(row: number): boolean; /** * Selects the text from the current position of the document until where a "page down" finishes. **/ selectPageDown(); /** * Selects the text from the current position of the document until where a "page up" finishes. **/ selectPageUp(); /** * Shifts the document to wherever "page down" is, as well as moving the cursor position. **/ gotoPageDown(); /** * Shifts the document to wherever "page up" is, as well as moving the cursor position. **/ gotoPageUp(); /** * Scrolls the document to wherever "page down" is, without changing the cursor position. **/ scrollPageDown(); /** * Scrolls the document to wherever "page up" is, without