fix: add mode types, improve type definitions

This change adds a new ace-modes.d.ts file (references in the main ace.d.ts),
which declares types for everything in the `ace/src/mode` folder.

It's been done semi-automatically, and every mode or highlight rules have the
same base type, even though technically different modes can have different
sub-types (so currently we are omitting some information).

Type definitions are excluded in the ace-builds package.

Also included small fixes for existing types, like EditSession or Config.

Author: ibabanov-aws

Makefile.dryice.js

@@ -171,7 +171,10 @@ function ace() {
 }
 
 function buildTypes() {
-    var definitions = fs.readFileSync(ACE_HOME + '/ace.d.ts', 'utf8');
+    var aceCodeModeDefinitions = '/// <reference path="./ace-modes.d.ts" />';
+    // ace-builds package has different structure and can't use mode types defined for the ace-code.
+    // ace-builds modes are declared along with other modules in the ace-modules.d.ts file below.
+    var definitions = fs.readFileSync(ACE_HOME + '/ace.d.ts', 'utf8').replace(aceCodeModeDefinitions, '');
     var paths = fs.readdirSync(BUILD_DIR + '/src-noconflict');
     var moduleRef = '/// <reference path="./ace-modules.d.ts" />';
 
@@ -193,21 +196,20 @@ function buildTypes() {
 
     fs.writeFileSync(BUILD_DIR + '/ace.d.ts', moduleRef + '\n' + definitions);
     fs.writeFileSync(BUILD_DIR + '/ace-modules.d.ts', pathModules);
-    
     var esmUrls = [];
+
     var loader = paths.map(function(path) {
         if (/\.js$/.test(path) && !/^ace\.js$/.test(path)) {
             var moduleName = path.split('.')[0].replace(/-/, "/");
             if (/^worker/.test(moduleName))
                 moduleName = "mode" + moduleName.slice(6) + "_worker";
             moduleName = moduleName.replace(/keybinding/, "keyboard");
-            
             esmUrls.push("ace.config.setModuleLoader('ace/" + moduleName + "', () => import('./src-noconflict/" + path + "'));");
             return "ace.config.setModuleUrl('ace/" + moduleName + "', require('file-loader?esModule=false!./src-noconflict/" + path + "'));";
         }
     }).join('\n');
     var esmLoader = esmUrls.join('\n');
-    
+
     fs.writeFileSync(BUILD_DIR + '/webpack-resolver.js', loader, "utf8");
     fs.writeFileSync(BUILD_DIR + '/esm-resolver.js', esmLoader, "utf8");
 }

ace-modes.d.ts

@@ -1,3 +1,5 @@
+/// <reference path="./ace-modes.d.ts" />
+
 export namespace Ace {
   export type NewLineMode = 'auto' | 'unix' | 'windows';
 
@@ -364,7 +366,66 @@ export namespace Ace {
     stepForward(): Token;
   }
 
+  export type HighlightRule = {defaultToken: string} | {include: string} | {todo: string} | {
+    token: string | string[] | ((value: string) => string);
+    regex: string | RegExp;
+    next?: string;
+    push?: string;
+    comment?: string;
+    caseInsensitive?: boolean;
+  }
+
+  export type HighlightRulesMap = Record<string, HighlightRule[]>;
+
+  export type KeywordMapper = (keyword: string) => string;
+
+  export interface HighlightRules {
+    $rules: HighlightRulesMap;
+    $embeds?: string[];
+    $keywordList?: string[];
+    $keywords?: KeywordMapper;
+    addRules(rules: HighlightRulesMap, prefix?: string): void;
+    getRules(): HighlightRulesMap;
+    embedRules(rules: (new () => HighlightRules) | HighlightRulesMap, prefix: string, escapeRules?: boolean, append?: boolean): void;
+    getEmbeds(): string[];
+    normalizeRules(): void;
+    createKeywordMapper(map: Record<string, string>, defaultToken?: string, ignoreCase?: boolean, splitChar?: string): KeywordMapper;
+  }
+
+  export interface FoldMode {
+    foldingStartMarker: RegExp;
+    foldingStopMarker?: RegExp;
+    getFoldWidget(session: EditSession, foldStyle: string, row: number): string;
+    getFoldWidgetRange(session: EditSession, foldStyle: string, row: number, forceMultiline?: boolean): Range | undefined;
+    indentationBlock(session: EditSession, row: number, column?: number): Range | undefined;
+    openingBracketBlock(session: EditSession, bracket: string, row: number, column: number, typeRe?: RegExp): Range | undefined;
+    closingBracketBlock(session: EditSession, bracket: string, row: number, column: number, typeRe?: RegExp): Range | undefined;
+  }
+
+  type BehaviorAction = (state: string, action: string, editor: Editor, session: EditSession, text: string) => {text: string, selection: number[]} | Range | undefined;
+  type BehaviorMap = Record<string, Record<string, BehaviorAction>>;
+
+  export interface Behaviour {
+    $behaviours: BehaviorMap;
+    add(name: string, action: string, callback: BehaviorAction): void;
+    addBehaviours(behaviours: BehaviorMap): void;
+    remove(name: string): void;
+    inherit(mode: SyntaxMode | (new () => SyntaxMode), filter: string[]): void;
+    getBehaviours(filter: string[]): BehaviorMap;
+  }
+
+  export interface Outdent {
+    checkOutdent(line: string, input: string): boolean;
+    autoOutdent(doc: Document, row: number): number | undefined;
+    $getIndent(line: string): string;
+  }
+
   export interface SyntaxMode {
+    HighlightRules: new () => HighlightRules;
+    foldingRules?: FoldMode;
+    $behaviour?: Behaviour;
+    $defaultBehaviour?: Behaviour;
+    lineCommentStart?: string;
     getTokenizer(): Tokenizer;
     toggleCommentLines(state: any,
       session: EditSession,
@@ -377,28 +438,28 @@ export namespace Ace {
     getNextLineIndent(state: any, line: string, tab: string): string;
     checkOutdent(state: any, line: string, input: string): boolean;
     autoOutdent(state: any, doc: Document, row: number): void;
+    $getIndent(line: string): string;
     // TODO implement WorkerClient types
     createWorker(session: EditSession): any;
     createModeDelegates(mapping: { [key: string]: string }): void;
-    transformAction(state: string,
-      action: string,
-      editor: Editor,
-      session: EditSession,
-      text: string): any;
+    transformAction: BehaviorAction;
     getKeywords(append?: boolean): Array<string | RegExp>;
     getCompletions(state: string,
       session: EditSession,
       pos: Point,
       prefix: string): Completion[];
   }
 
+  type AfterLoadCallback = (err: Error | null, module: unknown) => void;
+  type LoaderFunction = (moduleName: string, afterLoad: AfterLoadCallback) => void;
+
   export interface Config {
     get(key: string): any;
     set(key: string, value: any): void;
     all(): { [key: string]: any };
     moduleUrl(name: string, component?: string): string;
     setModuleUrl(name: string, subst: string): string;
-    setLoader(cb: Function): void;
+    setLoader(cb: LoaderFunction): void;
     setModuleLoader(name: string, onLoad: Function): void;
     loadModule(moduleName: string | [string, string],
       onLoad?: (module: any) => void): void;
@@ -455,11 +516,12 @@ export namespace Ace {
     on(name: 'tokenizerUpdate',
        callback: (obj: { data: { first: number, last: number } }) => void): Function;
     on(name: 'change', callback: () => void): Function;
+    on(name: 'changeTabSize', callback: () => void): Function;
 
 
     setOption<T extends keyof EditSessionOptions>(name: T, value: EditSessionOptions[T]): void;
     getOption<T extends keyof EditSessionOptions>(name: T): EditSessionOptions[T];
-    
+
     readonly doc: Document;
 
     setDocument(doc: Document): void;
@@ -817,7 +879,7 @@ export namespace Ace {
     setKeyboardHandler(keyboardHandler: string, callback?: () => void): void;
     setKeyboardHandler(keyboardHandler: KeyboardHandler|null): void;
     getKeyboardHandler(): string;
-    setSession(session: EditSession): void;
+    setSession(session: EditSession | undefined): void;
     getSession(): EditSession;
     setValue(val: string, cursorPos?: number): string;
     getValue(): string;
@@ -1032,7 +1094,7 @@ export const VirtualRenderer: {
   new(container: HTMLElement, theme?: string): Ace.VirtualRenderer;
 };
 export const EditSession: {
-  new(text: string | Document, mode?: Ace.SyntaxMode): Ace.EditSession;
+  new(text: string | Ace.Document, mode?: Ace.SyntaxMode): Ace.EditSession;
 };
 export const UndoManager: {
   new(): Ace.UndoManager;