Ckeditor4 update tools.d to reflect more upto date functions (4.20.0) (#65404)

* updating tools.d.ts to reflect newer functions

* cleanup from test and lint

* add tests for major elements

* fix lint error

types/ckeditor4/ckeditor4-tests.ts

@@ -1309,6 +1309,28 @@ function test_tools() {
     ckEditor.tools.tryThese(console.log, console.warn);
     str = ckEditor.tools.writeCssText(obj);
     str = ckEditor.tools.writeCssText(obj, true);
+
+    let rect: CKEDITOR.dom.rect = {
+        bottom: 1,
+        height: 1,
+        left: 1,
+        right: 1,
+        top: 1,
+        width: 1,
+        x: 1,
+        y: 1,
+    };
+
+    rect = ckEditor.tools.getAbsoluteRectPosition(new ckEditor.dom.window(window), rect);
+
+    let buffer = new ckEditor.tools.buffers.event(1000, fn);
+    buffer.input();
+    buffer.reset();
+    const fn2 = (test: string) => {
+        console.log('I was deferred by ' + test);
+    };
+    buffer = new ckEditor.tools.buffers.throttle(1000, fn2);
+    (buffer as CKEDITOR.tools.buffers.throttle).input('the throttle test.');
 }
 
 function test_plugins() {

types/ckeditor4/core/dom/dom.d.ts

@@ -601,6 +601,18 @@ declare namespace CKEDITOR {
             moveToBookmarks(bookmarks: bookmark[]): void;
         }
 
+        /** https://ckeditor.com/docs/ckeditor4/latest/api/CKEDITOR_dom_rect.html */
+        interface rect {
+            bottom: number;
+            height: number;
+            left: number;
+            right: number;
+            top: number;
+            width: number;
+            x: number;
+            y: number;
+        }
+
         /** https://ckeditor.com/docs/ckeditor4/latest/api/CKEDITOR_dom_selection.html */
         interface selection {
             readonly FILLING_CHAR_SEQUENCE: string;

types/ckeditor4/core/tools.d.ts

@@ -9,6 +9,10 @@ declare namespace CKEDITOR {
                 readonly parse: tools.style.parse;
                 readonly border: tools.style.borderConstructor;
             };
+            readonly buffers: {
+                readonly event: { new (minInterval: number, output: (...args: any[]) => void, contextObj?: object): tools.buffers.event }
+                readonly throttle: { new (minInterval: number, output: (...args: any[]) => void, contextObj?: object): tools.buffers.throttle }
+            };
         } & tools;
     }
     interface tools {
@@ -16,10 +20,58 @@ declare namespace CKEDITOR {
 
         arrayCompare(arrayA: unknown[], arrayB: unknown[]): boolean;
 
+        bind(func: (...args: any[]) => void, obj: object, args: unknown[]): (...args: any[]) => void;
+
+        buildStyleHtml(css: string | string[]): string;
+
+        buildTableMap(
+            table: dom.element,
+            startRow?: number,
+            startCell?: number,
+            endRow?: number,
+            endCell?: number,
+        ): void;
+
+        callFunction(ref: number, params?: unknown[]): unknown;
+
+        capitalize(str: string, keepCase?: boolean): string;
+
+        /**
+         * @version 4.4.0
+         */
+        checkIfAnyArrayItemMatches(arr: unknown[], regexp: RegExp): boolean;
+
+        /**
+         * @version 4.4.0
+         */
+        checkIfAnyObjectPropertyMatches(obj: object, regexp: RegExp): boolean;
+
         clone(source: { [key: string]: unknown }): {
             [key: string]: unknown;
         };
 
+        /**
+         * @version 4.1.0
+         */
+        convertArrayToObject(arr: unknown[], fillwith?: unknown): object;
+
+        /**
+         * @version 4.8.0
+         */
+        convertBytesToBase64(bytesArray: number[]): string;
+
+        /**
+         * @version 4.8.0
+         */
+        convertHexStringToBytes(hexString: string): number[];
+
+        convertRgbToHex(styleText: string): string;
+
+        convertToPx(cssLength: string): number | string;
+
+        /**
+         * @version 4.1.0
+         */
         copy(source: { [key: string]: unknown }): {
             [key: string]: unknown;
         };
@@ -36,12 +88,23 @@ declare namespace CKEDITOR {
 
         cssVendorPrefix(property: string, value: string, asString?: boolean): { [cssClass: string]: string | number };
 
-        defer(fn: () => void): void;
+        debounce(func: () => unknown, milliseconds?: number): () => unknown;
 
+        defer(fn: () => unknown): () => void;
+
+        /**
+         * @version 4.3.0
+         */
         enableHtml5Elements(doc: Document | DocumentFragment, withAppend?: boolean): void;
 
+        /**
+         * @version 4.5.10
+         */
         escapeCss(selector: string): string;
 
+        /**
+         * @version 4.2.1
+         */
         eventsBuffer(
             minInterval: number,
             output: () => void,
@@ -55,22 +118,47 @@ declare namespace CKEDITOR {
             properties: { [key: string]: unknown },
         ): { [key: string]: unknown };
 
+        /**
+         * @version 4.1.2
+         */
         fixDomain(): boolean;
 
         genKey(subKey: string): string;
 
+        /**
+         * @version 4.10.0
+         */
+        getAbsoluteRectPosition(window: dom.window, rect: dom.rect): dom.rect;
+
+        /**
+         * @version 4.5.6
+         */
         getCookie(name: string): string;
 
+        /**
+         * @version 4.5.6
+         */
         getCsrfToken(): string;
 
+        /**
+         * @version 4.5.0
+         */
         getIndex<T>(array: T[], compareFunction: (element: T) => boolean): number;
 
+        /**
+         * @version 4.7.3
+         */
         getMouseButton(evt: dom.event<Event | EventTarget>): boolean;
 
         getNextId(): string;
 
         getNextNumber(): number;
 
+        /**
+         * @version 4.15.0
+         */
+        getStyledSpans(property: string, source: dom.element): dom.element[];
+
         getUniqueId(): string;
 
         htmlDecode(text: string): string;
@@ -87,18 +175,38 @@ declare namespace CKEDITOR {
 
         isEmpty(object: { [key: string]: unknown }): boolean;
 
+        /**
+         * @version 4.8.0
+         */
         keystrokeToArray(lang: { [key: string]: unknown }, keystroke: number): { display: string[]; aria: string[] };
 
+        /**
+         * @version 4.8.0
+         */
         keystrokeToString(lang: { [key: string]: unknown }, keystroke: number): { display: string; aria: string };
 
         ltrim(str: string): string;
 
         normalizeCssText(styleText: string, nativeNormalize: boolean): string;
 
+        /**
+         * @deprecated 4.16.0
+         */
         normalizeHex(styleText: string): string;
 
+        /**
+         * @version 4.13.0
+         */
+        normalizeMouseButton(button: number, reverse?: boolean): number;
+
+        /**
+         * @version 4.1.0
+         */
         objectCompare(left: { [key: string]: unknown }, right: { [key: string]: unknown }, onlyLef?: boolean): boolean;
 
+        /**
+         * @deprecated 4.12.0
+         */
         objectKeys(obj: { [key: string]: unknown }): string[];
 
         override<T extends (...args: any[]) => any>(
@@ -120,6 +228,11 @@ declare namespace CKEDITOR {
 
         search<T>(array: T[], value: T | ((element: T) => boolean)): T;
 
+        /**
+         * @version 4.5.6
+         * @param name
+         * @param value
+         */
         setCookie(name: string, value: string): void;
 
         setTimeout(
@@ -130,12 +243,23 @@ declare namespace CKEDITOR {
             ownerWindow?: Window,
         ): number;
 
-        transformPlainTextToHtml(text: string, etnerMode: number): string;
+        /**
+         * @version 4.10.0
+         */
+        throttle(minInterval: number, output: () => void, contextObject?: unknown): tools.buffers.throttle;
+
+        /**
+         * @version: 4.5.0
+         */
+        transformPlainTextToHtml(text: string, enterMode: number): string;
 
         trim(str: string): string;
 
         tryThese(...fn: Array<(...args: unknown[]) => unknown>): unknown;
 
+        /**
+         * @version 4.1.0
+         */
         writeCssText(styles: { [key: string]: unknown }, sort?: boolean): string;
     }
 
@@ -253,5 +377,16 @@ declare namespace CKEDITOR {
                 width: string;
             }
         }
+
+        namespace buffers {
+            interface event {
+                input(): void;
+                reset(): void;
+            }
+
+            interface throttle extends event {
+                input(...args: any[]): void;
+            }
+        }
     }
 }