jodit 3.8.4 → 3.8.8

package/types/config.d.ts

@@ -54,12 +54,10 @@ export declare class Config implements IViewOptions {
     zIndex: number;
     /**
      * Change the read-only state of the editor
-     * @type {boolean}
      */
     readonly: boolean;
     /**
      * Change the disabled state of the editor
-     * @type {boolean}
      */
     disabled: boolean;
     activeButtonsInReadOnly: string[];
@@ -80,8 +78,6 @@ export declare class Config implements IViewOptions {
     allowTabNavigation: boolean;
     /**
      * Inline editing mode
-     *
-     * @type {boolean}
      */
     inline: boolean;
     /**
@@ -141,7 +137,7 @@ export declare class Config implements IViewOptions {
      * After all changes in editors for textarea will call change trigger
      *
      * @example
-     *  ```javascript
+     * ```javascript
      * var editor = new Jodit('#editor');
      * document.getElementById('editor').addEventListener('change', function () {
      *      console.log(this.value);
@@ -195,7 +191,7 @@ export declare class Config implements IViewOptions {
      */
     debugLanguage: boolean;
     /**
-     * Collection of language pack data {en: {'Type something': 'Type something', ...}}
+     * Collection of language pack data `{en: {'Type something': 'Type something', ...}}`
      *
      * @example
      * ```javascript
@@ -236,7 +232,6 @@ export declare class Config implements IViewOptions {
     showTooltipDelay: number;
     /**
      * Instead of create custop tooltip - use native title tooltips
-     * @type {boolean}
      */
     useNativeTooltip: boolean;
     /**
@@ -262,8 +257,6 @@ export declare class Config implements IViewOptions {
     defaultMode: number;
     /**
      * Use split mode
-     *
-     * @type {boolean}
      */
     useSplitMode: boolean;
     /**
@@ -339,6 +332,7 @@ export declare class Config implements IViewOptions {
      * But for a declarative declaration, you can use this option.
      *
      * @example
+     * ```js
      * Jodit.modules.Icon.set('someIcon', '<svg><path.../></svg>');
      * const editor = Jodit.make({
      *   extraButtons: [{
@@ -357,14 +351,16 @@ export declare class Config implements IViewOptions {
      *     icon: 'someIcon'
      *   }]
      * });
-     *
+     * ```
      * @example
+     * ```js
      * const editor = Jodit.make({
      *   extraButtons: [{
      *     name: 'someButton',
      *     icon: '<svg><path.../></svg>'
      *   }]
      * });
+     * ```
      */
     extraIcons: IDictionary<string>;
     /**
@@ -444,7 +440,7 @@ export declare class Config implements IViewOptions {
      *            return '<div>' + value + '</div>';
      *        }
      *  });
-     *  ```
+     * ```
      */
     buttons: ButtonsOption;
     /**
@@ -456,7 +452,7 @@ export declare class Config implements IViewOptions {
      */
     buttonsSM: ButtonsOption;
     /**
-     * The list of buttons that appear in the editor's toolbar on extra small places (< options.sizeSM).
+     * The list of buttons that appear in the editor's toolbar on extra small places `(< options.sizeSM)`.
      */
     buttonsXS: ButtonsOption;
     /**
@@ -466,12 +462,10 @@ export declare class Config implements IViewOptions {
     events: IDictionary<(...args: any[]) => any>;
     /**
      * Buttons in toolbat without SVG - only texts
-     * @type {boolean}
      */
     textIcons: boolean;
     /**
      * shows a INPUT[type=color] to open the browser color picker, on the right bottom of widget color picker
-     * @type {boolean}
      */
     showBrowserColorPicker: boolean;
     private static __defaultOptions;

package/types/core/ajax.d.ts

@@ -4,34 +4,11 @@
  * Copyright (c) 2013-2021 Valeriy Chupurnov. All rights reserved. https://xdsoft.net
  */
 import type { IRequest, IViewBased, AjaxOptions, IAjax } from '../types';
-/**
- * @property {object} defaultAjaxOptions A set of key/value pairs that configure the Ajax request. All settings
- * are optional
- * @property {object} defaultAjaxOptions.headers An object of additional header key/value pairs toWYSIWYG send along
- * with requests using the XMLHttpRequest transport. Uses in {@link FileBrowser|FileBrowser}
- * and {@link Uploader|Uploader}
- * @property {string} defaultAjaxOptions.dataType='json' json or text The type of data that you're expecting back
- * from the server. if `json` the return value passes through the `JSON.parse`
- * @property {string} defaultAjaxOptions.method='GET' The HTTP method toWYSIWYG use for the request
- * (e.g. "POST", "GET", "PUT")
- * @property {string} defaultAjaxOptions.url='' A string containing the URL toWYSIWYG which the request is sent.
- * @property {string} defaultAjaxOptions.async=true By default, all requests are sent asynchronously (i.e. this is
- * set toWYSIWYG true by default). If you need synchronous requests, set this option toWYSIWYG false
- * @property {object|string} defaultAjaxOptions.data=null Data toWYSIWYG be sent toWYSIWYG the server.
- * It is converted toWYSIWYG a query string, if not already a string. It's appended toWYSIWYG the url for GET-requests.
- * @property {string} defaultAjaxOptions.contentType='application/x-www-form-urlencoded; charset=UTF-8'
- * When sending data toWYSIWYG the server, use this content type. Default is "application/x-www-form-urlencoded;
- * charset=UTF-8", which is fine for most cases
- * @property {boolean} defaultAjaxOptions.withCredentials=false
- * Enable or disable Access-Control-Allow-Credentials client side. Useful for cross domain requests
- * @property {function} defaultAjaxOptions.error=function () {} A function toWYSIWYG be called if the request fails
- * @property {function} defaultAjaxOptions.success=function (resp) {} A function toWYSIWYG be called if the
- * request succeeds
- * @property {function} defaultAjaxOptions.xhr=function () { return new XMLHttpRequest(); } Callback for creating
- * the XMLHttpRequest object.
- */
 declare module '../config' {
     interface Config {
+        /**
+         * A set of key/value pairs that configure the Ajax request. All settings are optional
+         */
         defaultAjaxOptions: AjaxOptions;
     }
 }
@@ -39,7 +16,7 @@ export declare class Ajax implements IAjax {
     readonly jodit: IViewBased;
     static log: IRequest[];
     private readonly xhr;
-    private success_response_codes;
+    private successResponseCodes;
     private __buildParams;
     status: number;
     response: string;
@@ -52,8 +29,8 @@ export declare class Ajax implements IAjax {
     abort(): Ajax;
     private resolved;
     private activated;
-    send(): Promise<any>;
+    send<T = any>(): Promise<T>;
     prepareRequest(): IRequest;
     constructor(jodit: IViewBased, options: Partial<AjaxOptions>);
-    destruct(): any;
+    destruct(): void;
 }

package/types/core/async.d.ts

@@ -14,10 +14,6 @@ export declare class Async implements IAsync {
      * Debouncing enforces that a function not be called again until a certain amount of time has passed without
      * it being called. As in "execute this function only if 100 milliseconds have passed without it being called."
      *
-     * @param {function} fn
-     * @param {int} timeout
-     * @return {function}
-     *
      * @example
      * ```javascript
      * var jodit = new Jodit('.editor');
@@ -26,20 +22,12 @@ export declare class Async implements IAsync {
      * }, 100));
      * ```
      *
-     * @param fn
-     * @param timeout
-     * @param firstCallImmediately
      */
     debounce(fn: CallbackFunction, timeout: ITimeout | IAsyncParams, firstCallImmediately?: boolean): CallbackFunction;
     /**
      * Throttling enforces a maximum number of times a function can be called over time.
      * As in "execute this function at most once every 100 milliseconds."
      *
-     * @method throttle
-     * @param {function} fn
-     * @param {int} timeout
-     * @param {context} [ctx] Context
-     * @return {function}
      * @example
      * ```javascript
      * var jodit = new Jodit('.editor');
@@ -53,14 +41,13 @@ export declare class Async implements IAsync {
     promise<T>(executor: (resolve: (value: T | PromiseLike<T>) => void, reject?: (reason?: any) => void) => void): RejectablePromise<T>;
     /**
      * Get Promise status
-     * @param p
      */
     promiseState(p: Promise<any>): Promise<'pending' | 'fulfilled' | 'rejected'>;
     private requestsIdle;
     private requestIdleCallbackNative;
     private cancelIdleCallbackNative;
-    requestIdleCallback(callback: CallbackFunction): number;
-    requestIdlePromise(): Promise<number>;
+    requestIdleCallback(callback: IdleRequestCallback): number;
+    requestIdlePromise(): RejectablePromise<number>;
     cancelIdleCallback(request: number): void;
     clear(): void;
     isDestructed: boolean;

package/types/core/component/view-component.d.ts

@@ -18,7 +18,6 @@ export declare abstract class ViewComponent<T extends IViewBased = IViewBased> e
     i18n(text: string, ...params: Array<string | number>): string;
     /**
      * Attach component to View
-     * @param jodit
      */
     setParentView(jodit: T): this;
     constructor(jodit: T);

package/types/core/constants.d.ts

@@ -33,24 +33,24 @@ export declare const COMMAND_KEYS: string[];
 export declare const BR = "br";
 export declare const PARAGRAPH = "p";
 /**
- * @property {int} MODE_WYSIWYG=1 WYSIWYG editor mode
+ * WYSIWYG editor mode
  */
 export declare const MODE_WYSIWYG = 1;
 /**
- * @property {int} MODE_SOURCE=2 html editor mode
+ * html editor mode
  */
 export declare const MODE_SOURCE = 2;
 /**
- * @property {int} MODE_SPLIT=3  Source code editor and HTML editor both like
+ * Source code editor and HTML editor both like
  * {@link http://getuikit.com/docs/htmleditor.html|this}
  */
 export declare const MODE_SPLIT = 3;
 /**
- * @property {boolean} Is Internet Explorer
+ * Is Internet Explorer
  */
 export declare const IS_IE: boolean;
 /**
- * @property {string} TEXT_PLAIN='text/plain'  For IE11 it will be 'text'. Need for dataTransfer.setData
+ * For IE11 it will be 'text'. Need for dataTransfer.setData
  */
 export declare const TEXT_PLAIN: string;
 export declare const TEXT_HTML: string;

package/types/core/create.d.ts

@@ -9,10 +9,6 @@ export declare class Create implements ICreate {
     readonly createAttributes?: CanUndef<IDictionary<Attributes | NodeFunction>>;
     private get doc();
     constructor(document: Document | (() => Document), createAttributes?: CanUndef<IDictionary<Attributes | NodeFunction>>);
-    /**
-     * Apply some object key-value to HTMLElement
-     */
-    private applyAttributes;
     element<K extends keyof HTMLElementTagNameMap>(tagName: K, children?: Children): HTMLElementTagNameMap[K];
     element<K extends keyof HTMLElementTagNameMap>(tagName: K, attributes?: Attributes, children?: Children): HTMLElementTagNameMap[K];
     div(className?: string, childrenOrAttributes?: Children): HTMLDivElement;

package/types/core/decorators/debounce.d.ts

@@ -6,17 +6,9 @@
 import type { IViewBased, IViewComponent, IAsyncParams, DecoratorHandler } from '../../types';
 /**
  * Wrap function in debounce wrapper
- *
- * @param timeout
- * @param firstCallImmediately
- * @param method
  */
 export declare function debounce<V = IViewComponent | IViewBased>(timeout?: number | ((ctx: V) => number | IAsyncParams) | IAsyncParams, firstCallImmediately?: boolean, method?: 'debounce' | 'throttle'): DecoratorHandler;
 /**
  * Wrap function in throttle wrapper
- *
- * @param timeout
- * @param firstCallImmediately
- * @param method
  */
 export declare function throttle<V = IViewComponent | IViewBased>(timeout?: number | ((ctx: V) => number | IAsyncParams) | IAsyncParams, firstCallImmediately?: boolean): DecoratorHandler;

package/types/core/decorators/hook.d.ts

@@ -7,6 +7,5 @@ import type { ComponentStatus, IDictionary } from '../../types';
 import type { Component } from '../component';
 /**
  * Call on some component status
- * @param timeout
  */
 export declare function hook(status: ComponentStatus): <T extends Component & IDictionary<any>>(target: IDictionary, propertyKey: string) => void;

package/types/core/decorators/nonenumerable.d.ts

@@ -4,7 +4,6 @@
  * Copyright (c) 2013-2021 Valeriy Chupurnov. All rights reserved. https://xdsoft.net
  */
 /**
- * @enumerable decorator that sets the enumerable property of a class field to false.
- * @param value true|false
+ * Decorator that sets the enumerable property of a class field to false.
  */
 export declare const nonenumerable: (target: object, propertyKey: string) => void;

package/types/core/decorators/persistent.d.ts

@@ -6,8 +6,5 @@
 import type { IComponent } from '../../types';
 /**
  * Allow save value inside persistent storage as set/get to property
- *
- * @param target
- * @param propertyKey
  */
 export declare function persistent<T extends IComponent>(target: T, propertyKey: string): void;

package/types/core/decorators/wait.d.ts

@@ -6,7 +6,6 @@
 import type { IViewBased, IViewComponent } from '../../types';
 /**
  * Wrap function in wait wrapper, it will be called after `condition` returns `true`
- * @param condition
  */
 export declare function wait<T extends IViewBased>(condition: (ctx: T) => boolean): Function;
 export declare function wait<T extends IViewComponent>(condition: (ctx: T) => boolean): Function;

package/types/core/dom.d.ts

@@ -3,42 +3,32 @@
  * Released under MIT see LICENSE.txt in the project root for license information.
  * Copyright (c) 2013-2021 Valeriy Chupurnov. All rights reserved. https://xdsoft.net
  */
-import type { HTMLTagNames, ICreate, IJodit, NodeCondition, Nullable } from '../types';
+import type { HTMLTagNames, ICreate, IJodit, NodeCondition, Nullable, IDictionary } from '../types';
 /**
  * Module for working with DOM
  */
 export declare class Dom {
     /**
      * Remove all content from element
-     * @param node
      */
     static detach(node: Node): void;
     /**
      * Wrap all inline siblings
-     *
-     * @param current
-     * @param tag
-     * @param editor
      */
     static wrapInline(current: Node, tag: Node | HTMLTagNames, editor: IJodit): HTMLElement;
     /**
      * Wrap node inside another node
-     *
-     * @param current
-     * @param tag
-     * @param editor
      */
     static wrap<K extends HTMLTagNames>(current: Node, tag: K, create: ICreate): HTMLElementTagNameMap[K];
     /**
      * Remove parent of node and insert this node instead that parent
-     * @param node
      */
     static unwrap(node: Node): void;
     /**
      * It goes through all the internal elements of the node, causing a callback function
      *
-     * @param elm elements , the internal node is necessary to sort out
-     * @param callback It called for each item found
+     * @param elm - the element whose children and descendants you want to iterate over
+     * @param callback - It called for each item found
      * @example
      * ```javascript
      * Jodit.modules.Dom.each(parent.s.current(), function (node) {
@@ -52,20 +42,15 @@ export declare class Dom {
     static each(elm: Node | HTMLElement, callback: (node: Node) => void | boolean): boolean;
     /**
      * Call function for all nodes between `start` and `end`
-     *
-     * @param start
-     * @param end
      */
     static between(start: Node, end: Node, callback: (node: Node) => void | boolean): void;
     /**
      * Replace one tag to another transfer content
      *
-     * @param  {Node} elm The element that needs to be replaced by new
-     * @param  {string} newTagName tag name for which will change `elm`
-     * @param  {boolean} withAttributes=false If true move tag's attributes
-     * @param  {boolean} notMoveContent=false false - Move content from elm to newTagName
-     * @param  {Document} [doc=document]
-     * @return {Node} Returns a new tag
+     * @param elm - The element that needs to be replaced by new
+     * @param newTagName - tag name for which will change `elm`
+     * @param withAttributes - If true move tag's attributes
+     * @param notMoveContent - false - Move content from elm to newTagName
      * @example
      * ```javascript
      * Jodit.modules.Dom.replace(parent.editor.getElementsByTagName('span')[0], 'p');
@@ -77,16 +62,11 @@ export declare class Dom {
      * Checks whether the Node text and blank (in this case it may contain invisible auxiliary characters ,
      * it is also empty )
      *
-     * @param  {Node} node The element of wood to be checked
-     * @return {Boolean} true element is empty
+     * @param node - The element of wood to be checked
      */
     static isEmptyTextNode(node: Node): boolean;
     /**
      * Check if element is empty
-     *
-     * @param {Node} node
-     * @param {RegExp} condNoEmptyElement
-     * @return {boolean}
      */
     static isEmpty(node: Node, condNoEmptyElement?: RegExp): boolean;
     /**
@@ -95,14 +75,10 @@ export declare class Dom {
     static isNode(object: unknown): object is Node;
     /**
      *  Check if element is table cell
-     * @param elm
      */
     static isCell(elm: unknown): elm is HTMLTableCellElement;
     /**
      * Check is element is Image element
-     *
-     * @param {Node} elm
-     * @return {boolean}
      */
     static isImage(elm: unknown): elm is HTMLImageElement;
     /**
@@ -112,22 +88,18 @@ export declare class Dom {
     static isBlock(node: unknown): node is HTMLDivElement;
     /**
      * Check if element is text node
-     * @param node
      */
     static isText(node: Node | null | false): node is Text;
     /**
      * Check if element is element node
-     * @param node
      */
-    static isElement(node: Node | null | false | EventTarget | object): node is Element;
+    static isElement(node: unknown): node is Element;
     /**
      * Check if element is HTMLElement node
-     * @param node
      */
     static isHTMLElement(node: unknown): node is HTMLElement;
     /**
      * Check element is inline block
-     * @param node
      */
     static isInlineBlock(node: Node | null | false): node is HTMLElement;
     /**
@@ -136,167 +108,108 @@ export declare class Dom {
     static canSplitBlock(node: unknown): boolean;
     /**
      * Get last matched node inside root
-     *
-     * @param root
-     * @param condition
      */
     static last(root: Nullable<Node>, condition: NodeCondition): Nullable<Node>;
     /**
      * Find previous node
-     *
-     * @param node
-     * @param condition
-     * @param root
-     * @param [withChild]
      */
     static prev(node: Node, condition: NodeCondition, root: Node | HTMLElement | ParentNode, withChild?: boolean): Nullable<Node>;
     /**
      * Find next node what `condition(next) === true`
-     *
-     * @param node
-     * @param condition
-     * @param root
-     * @param [withChild]
      */
     static next(node: Node, condition: NodeCondition, root: Node | HTMLElement | ParentNode, withChild?: boolean): Nullable<Node>;
     static prevWithClass(node: HTMLElement, className: string): Nullable<HTMLElement>;
     static nextWithClass(node: HTMLElement, className: string): Nullable<HTMLElement>;
     /**
      * Find next/prev node what `condition(next) === true`
-     *
-     * @param node
-     * @param condition
-     * @param root
-     * @param [recurse] check first argument
-     * @param [sibling] nextSibling or previousSibling
-     * @param [child] firstChild or lastChild
      */
     static find(node: Node, condition: NodeCondition, root: ParentNode | HTMLElement | Node, recurse?: boolean, sibling?: keyof Node, child?: keyof Node | false): Nullable<Node>;
     /**
      * Find next/prev node what `condition(next) === true`
-     *
-     * @param node
-     * @param condition
-     * @param root
-     * @param [sibling] nextSibling or previousSibling
-     * @param [child] firstChild or lastChild
      */
     static findWithCurrent(node: Node, condition: NodeCondition, root: HTMLElement | Node, sibling?: 'nextSibling' | 'previousSibling', child?: 'firstChild' | 'lastChild'): Nullable<Node>;
     /**
      * Get not empty  sibling
-     *
-     * @param node
-     * @param [left]
-     * @param [cond]
      */
     static findSibling(node: Node, left?: boolean, cond?: (n: Node) => boolean): Nullable<Node>;
     /**
      * It goes through all the elements in ascending order, and checks to see if they meet the predetermined condition
-     *
-     * @param node
-     * @param condition
-     * @param [root] Root element
-     * @param [checkRoot]
      */
     static up<T extends HTMLElement>(node: Nullable<Node>, condition: NodeCondition, root?: Node, checkRoot?: boolean): Nullable<T>;
     /**
      * Find parent by tag name
-     *
-     * @param node
-     * @param tags
-     * @param root
      */
     static closest<T extends HTMLElement, K extends HTMLTagNames>(node: Nullable<Node>, tags: K, root: HTMLElement): Nullable<HTMLElementTagNameMap[K]>;
     static closest<T extends HTMLElement, K extends keyof HTMLElementTagNameMap>(node: Nullable<Node>, tags: K[], root: HTMLElement): Nullable<HTMLElementTagNameMap[K]>;
     static closest<T extends HTMLElement>(node: Nullable<Node>, condition: NodeCondition, root: HTMLElement): Nullable<T>;
     /**
      * Furthest parent node matching condition
-     *
-     * @param node
-     * @param condition
-     * @param root
      */
     static furthest<T extends HTMLElement>(node: Nullable<Node>, condition: NodeCondition, root: HTMLElement): Nullable<T>;
     /**
      * Append new element in the start of root
-     * @param root
-     * @param newElement
      */
     static appendChildFirst(root: HTMLElement, newElement: HTMLElement | DocumentFragment): void;
     /**
      * Insert newElement after element
-     *
-     * @param elm
-     * @param newElement
      */
     static after(elm: Node, newElement: Node | DocumentFragment): void;
     /**
      * Insert newElement before element
-     *
-     * @param elm
-     * @param newElement
      */
     static before(elm: Node, newElement: Node | DocumentFragment): void;
     /**
      * Insert newElement as first child inside element
-     *
-     * @param elm
-     * @param newElement
      */
     static prepend(root: Node, newElement: Node | DocumentFragment): void;
     /**
      * Insert newElement as last child inside element
-     *
-     * @param elm
-     * @param newElement
      */
     static append(root: Node, newElements: Array<Node | DocumentFragment>): void;
     static append(root: Node, newElement: Node | DocumentFragment): void;
     /**
      * Move all content to another element
-     *
-     * @param from
-     * @param to
-     * @param inStart
      */
     static moveContent(from: Node, to: Node, inStart?: boolean): void;
     /**
      * Call callback condition function for all elements of node
-     *
-     * @param node
-     * @param condition
-     * @param prev
      */
     static all(node: Node, condition: NodeCondition, prev?: boolean): Nullable<Node>;
     /**
      * Check root contains child or equal child
-     *
-     * @param root
-     * @param child
-     * @param [onlyContains]
      */
     static isOrContains(root: Node, child: Node, onlyContains?: boolean): boolean;
     /**
      * Safe remove element from DOM
-     * @param node
      */
     static safeRemove(node: Node | false | null | void): void;
     /**
      * Hide element
-     * @param node
      */
     static hide(node: Nullable<HTMLElement>): void;
     /**
      * Show element
-     * @param node
      */
     static show(node: Nullable<HTMLElement>): void;
     /**
      * Check if element is some tag
-     *
-     * @param node
-     * @param tagNames
      */
     static isTag<K extends keyof HTMLElementTagNameMap>(node: Node | null | false | EventTarget, tagName: K): node is HTMLElementTagNameMap[K];
     static isTag<K extends keyof HTMLElementTagNameMap>(node: Node | null | false | EventTarget, tagNames: K[]): node is HTMLElementTagNameMap[K];
+    /**
+     * Marks an item as temporary
+     */
+    static markTemporary<K extends HTMLElement>(element: K, attributes?: IDictionary): K;
+    /**
+     * Check if element is temporary
+     */
+    static isTemporary(element: unknown): boolean;
+    /**
+     * Replace temporary elements from string
+     */
+    static replaceTemporaryFromString(value: string): string;
+    /**
+     * Get temporary list
+     */
+    static temporaryList(root: HTMLElement): HTMLElement[];
 }