jodit 3.8.5 → 3.9.2

package/types/core/helpers/checker/is-equal.d.ts

@@ -5,9 +5,6 @@
  */
 /**
  * Check two element are equal
- *
- * @param a
- * @param b
  */
 export declare function isEqual(a: unknown, b: unknown): boolean;
 export declare function isFastEqual(a: unknown, b: unknown): boolean;

package/types/core/helpers/checker/is-function.d.ts

@@ -5,7 +5,5 @@
  */
 /**
  * Check value is Function
- *
- * @param value
  */
 export declare function isFunction(value: unknown): value is Function;

package/types/core/helpers/checker/is-html-from-word.d.ts

@@ -5,8 +5,5 @@
  */
 /**
  * Detect if string is HTML from MS Word or Excel
- *
- * @param {string} data
- * @return {boolean}
  */
 export declare function isHtmlFromWord(data: string): boolean;

package/types/core/helpers/checker/is-html.d.ts

@@ -5,6 +5,5 @@
  */
 /**
  * Check if a string is html or not
- ** @param str
  */
 export declare const isHTML: (str: unknown) => str is string;

package/types/core/helpers/checker/is-number.d.ts

@@ -5,6 +5,5 @@
  */
 /**
  * Check value is a number
- * @param value
  */
 export declare function isNumber(value: unknown): value is number;

package/types/core/helpers/checker/is-numeric.d.ts

@@ -5,7 +5,5 @@
  */
 /**
  * Check value has numeric format
- *
- * @param value
  */
 export declare function isNumeric(value: number | string): boolean;

package/types/core/helpers/checker/is-plain-object.d.ts

@@ -6,6 +6,5 @@
 import type { IDictionary } from '../../../types';
 /**
  * Check if element is simple plaint object
- * @param obj
  */
 export declare function isPlainObject<T>(obj: any | IDictionary<T>): obj is IDictionary<T>;

package/types/core/helpers/checker/is-string.d.ts

@@ -5,6 +5,5 @@
  */
 /**
  * Check value is String
- * @param value
  */
 export declare function isString(value: unknown): value is string;

package/types/core/helpers/checker/is-url.d.ts

@@ -5,9 +5,5 @@
  */
 /**
  * Check if a string is a url
- *
- * @method isURL
- * @param {string} str
- * @return {boolean}
  */
 export declare function isURL(str: string): boolean;

package/types/core/helpers/color/color-to-hex.d.ts

@@ -6,8 +6,8 @@
 /**
  * Converts rgba text representation of color in hex
  *
- * @param {string} color - string like rgba(red, green, blue, alpha) or rgb(red, green, blue)
- * @return {string | NaN} hex color view, NaN - for transparent color
+ * @param color - string like rgba(red, green, blue, alpha) or rgb(red, green, blue)
+ * @returns hex color view, NaN - for transparent color
  * @example
  * ```javascript
  * var p = document.createElement('p');

package/types/core/helpers/config-proto.d.ts

@@ -33,9 +33,6 @@ import type { IDictionary } from '../../types';
  * console.log(options.d.g); // 8
  *
  * ```
- * @param options
- * @param proto
- * @param level
  */
 export declare function ConfigProto(options: IDictionary, proto: IDictionary, deep?: number): IDictionary;
 export declare function ConfigFlatten(obj: IDictionary): IDictionary;

package/types/core/helpers/convert-media-url-to-video-embed.d.ts

@@ -4,11 +4,6 @@
  * Copyright (c) 2013-2021 Valeriy Chupurnov. All rights reserved. https://xdsoft.net
  */
 /**
- *  Javascript url pattern converter replace youtube/vimeo url in embed code.
- *
- * @param {string} url
- * @param {int} [width=400]
- * @param {int} [height=345]
- * return {string} embed code
+ * Javascript url pattern converter replace youtube/vimeo url in embed code.
  */
 export declare const convertMediaUrlToVideoEmbed: (url: string, width?: number, height?: number) => string;

package/types/core/helpers/ctrl-key.d.ts

@@ -5,8 +5,6 @@
  */
 /**
  * CTRL pressed
- *
- * @param  {KeyboardEvent} e Event
- * @return {boolean} true ctrl key was pressed
+ * @returns true ctrl key was pressed
  */
 export declare const ctrlKey: (e: MouseEvent | KeyboardEvent) => boolean;

package/types/core/helpers/data-bind.d.ts

@@ -4,10 +4,4 @@
  * Copyright (c) 2013-2021 Valeriy Chupurnov. All rights reserved. https://xdsoft.net
  */
 import type { IViewComponent } from '../../types';
-/**
- *
- * @param elm
- * @param key
- * @param value
- */
 export declare const dataBind: <T = any>(elm: IViewComponent | Node | object, key: string, value?: T | undefined) => T;

package/types/core/helpers/default-language.d.ts

@@ -5,8 +5,5 @@
  */
 /**
  * Try define user language
- *
- * @param language
- * @param defaultLanguage
  */
 export declare const defaultLanguage: (language?: string | undefined, defaultLanguage?: string) => string;

package/types/core/helpers/each.d.ts

@@ -5,7 +5,16 @@
  */
 import type { IDictionary } from '../../types';
 declare type eachCallback<T, N> = (this: T, key: N, value: T) => boolean | void;
+/**
+ * @deprecated Use Object.keys
+ */
 export declare function each<T>(obj: T[], callback: eachCallback<T, number>): boolean;
+/**
+ * @deprecated Use Object.keys
+ */
 export declare function each<T>(obj: IDictionary<T>, callback: eachCallback<T, string>): boolean;
+/**
+ * @deprecated Use Object.keys
+ */
 export declare function each<T>(obj: T[] | IDictionary<T>, callback: eachCallback<T, number | string>): boolean;
 export {};

package/types/core/helpers/html/htmlspecialchars.d.ts

@@ -5,9 +5,5 @@
  */
 /**
  * Convert special characters to HTML entities
- *
- * @method htmlspecialchars
- * @param {string} html
- * @return {string}
  */
 export declare function htmlspecialchars(html: string): string;

package/types/core/helpers/html/nl2br.d.ts

@@ -5,6 +5,5 @@
  */
 /**
  *  Inserts HTML line breaks before all newlines in a string
- * @param html
  */
 export declare function nl2br(html: string): string;

package/types/core/helpers/human-size-to-bytes.d.ts

@@ -5,9 +5,6 @@
  */
 /**
  * Converts from human readable file size (kb,mb,gb,tb) to bytes
- *
- * @method humanSizeToBytes
- * @param {string|int} human readable file size. Example 1gb or 11.2mb
- * @return {int}
+ * @param human - readable file size. Example 1gb or 11.2mb
  */
 export declare const humanSizeToBytes: (human: string) => number;

package/types/core/helpers/normalize/normalize-color.d.ts

@@ -6,8 +6,7 @@
 /**
  * Convert rgba and short HEX color to Full text color. #fff to #FFFFFF
  *
- * @method normalizeColor
- * @param {string} colorInput - string like rgba(red, green, blue, alpha) or rgb(red, green, blue) or #fff or #ffffff
- * @return {string|boolean} HEX color, false - for transparent color
+ * @param colorInput - string like rgba(red, green, blue, alpha) or rgb(red, green, blue) or #fff or #ffffff
+ * @returns HEX color, false - for transparent color
  */
 export declare const normalizeColor: (colorInput: string) => string | false;

package/types/core/helpers/normalize/normalize-key-aliases.d.ts

@@ -5,7 +5,5 @@
  */
 /**
  * Normalize keys to some standard name
- *
- * @param keys
  */
 export declare function normalizeKeyAliases(keys: string): string;

package/types/core/helpers/normalize/normalize-path.d.ts

@@ -5,7 +5,5 @@
  */
 /**
  * Replaces back slashes and correctly concatenates several parts of the path.
- * @param path
- * @see Test helpers
  */
 export declare const normalizePath: (...path: string[]) => string;

package/types/core/helpers/normalize/normalize-size.d.ts

@@ -5,8 +5,5 @@
  */
 /**
  * Normalize value to CSS meters
- * @method normalizeSize
- * @param {string|int} value Input string
- * @return {string}
  */
 export declare const normalizeSize: (value: string | number) => string;

package/types/core/helpers/selector.d.ts

@@ -23,25 +23,17 @@ export declare function $$<K extends HTMLTagNames>(selector: K, root: HTMLElemen
 export declare function $$<T extends HTMLElement>(selector: string, root: HTMLElement | HTMLDocument): T[];
 /**
  * Calculate XPath selector
- *
- * @param element
- * @param root
  */
 export declare const getXPathByElement: (element: HTMLElement, root: HTMLElement) => string;
 /**
  * Find all `ref` or `data-ref` elements inside HTMLElement
- * @param root
  */
 export declare const refs: <T extends HTMLElement>(root: HTMLElement | UIElement) => IDictionary<T>;
 /**
  * Calculate full CSS selector
- * @param el
  */
 export declare const cssPath: (el: Element) => Nullable<string>;
 /**
  * Try to find element by selector
- *
- * @param element
- * @param od
  */
 export declare function resolveElement(element: string | HTMLElement, od: ShadowRoot | Document): HTMLElement;

package/types/core/helpers/size/get-content-width.d.ts

@@ -5,7 +5,5 @@
  */
 /**
  *
- * @param element
- * @param win
  */
 export declare const getContentWidth: (element: HTMLElement, win: Window) => number;

package/types/core/helpers/size/offset.d.ts

@@ -5,13 +5,7 @@
  */
 /**
  * Calc relative offset by start editor field
- *
- * @method offset
- * @param {HTMLElement} elm
- * @param {Jodit} jodit
- * @param {Document} doc
- * @param {boolean} recurse
- * @return {{top: number, left: number}} returns an object containing the properties top and left.
+ * @returns returns an object containing the properties top and left.
  */
 import type { IBound, IViewBased } from '../../../types';
 export declare const offset: (elm: HTMLElement | Range, jodit: IViewBased, doc: Document, recurse?: boolean) => IBound;

package/types/core/helpers/string/camel-case.d.ts

@@ -4,7 +4,6 @@
  * Copyright (c) 2013-2021 Valeriy Chupurnov. All rights reserved. https://xdsoft.net
  */
 /**
- * Convert (kebab-case or snake_case) => camelCase
- * @param key
+ * Convert (kebab-case or snake_case) to camelCase
  */
 export declare const camelCase: (key: string) => string;

package/types/core/helpers/string/i18n.d.ts

@@ -6,17 +6,10 @@
 import type { ILanguageOptions } from '../../../types';
 /**
  * Simple variant sprintf function
- *
- * @param str
- * @param args
  */
 export declare const sprintf: (str: string, args?: (string | number)[] | undefined) => string;
 /**
  * Internationalization method. Uses Jodit.lang object
- *
- * @param {string} key Some text
- * @param {string[]} params Some text
- * @return {string}
  * @example
  * ```javascript
  * var editor = new Jodit("#redactor", {

package/types/core/helpers/string/kebab-case.d.ts

@@ -3,9 +3,5 @@
  * 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
  */
-/**
- *
- * @param key
- * @return {string}
- */
 export declare const kebabCase: (key: string) => string;
+export declare const CamelCaseToKebabCase: (key: string) => string;

package/types/core/helpers/string/stringify.d.ts

@@ -5,9 +5,6 @@
  */
 /**
  * Safe stringify circular object
- *
- * @param value
- * @param options
  */
 export declare function stringify(value: unknown, options?: {
     excludeKeys?: string[];

package/types/core/helpers/string/trim.d.ts

@@ -6,11 +6,9 @@
 /**
  * It clears the line of all auxiliary invisible characters , from the spaces and line breaks , tabs
  * from the beginning and end of the line
- * @param value input string
  */
 export declare function trim(value: string): string;
 /**
  * Trim only invisible chars
- * @param value
  */
 export declare function trimInv(value: string): string;

package/types/core/helpers/string/ucfirst.d.ts

@@ -5,8 +5,5 @@
  */
 /**
  * Make a string's first character uppercase
- *
- * @param {string} value input string
- * @return {string}
  */
-export declare const ucfirst: (value: string) => string;
+export declare function ucfirst(value: string): string;

package/types/core/helpers/type.d.ts

@@ -5,6 +5,5 @@
  */
 /**
  * Helper for create Error object
- * @param message
  */
 export declare function error(message: string): Error;

package/types/core/helpers/utils/get.d.ts

@@ -22,7 +22,5 @@ import type { IDictionary, Nullable } from '../../../types';
  * console.log(Jodit.modules.Helpers.get('a.b.c.d.e', obj) === false); // true
  * console.log(Jodit.modules.Helpers.get('a.b.a.d.e', obj) === null); // false
  * ```
- * @param chain
- * @param obj
  */
 export declare function get<T>(chain: string, obj: IDictionary): Nullable<T>;

package/types/core/helpers/utils/mark-deprecated.d.ts

@@ -10,9 +10,5 @@
 export declare const cns: Console;
 /**
  * Mark function as deprecated
- *
- * @param method
- * @param names
- * @param ctx
  */
 export declare function markDeprecated(method: Function, names?: string[], ctx?: any): (...args: any[]) => void;

package/types/core/helpers/utils/set.d.ts

@@ -16,7 +16,5 @@ import type { IDictionary } from '../../../types';
  * Jodit.modules.Helpers.set('a.0.e', 1, b);
  * console.log(b);// {a: [{e: 1}]}
  * ```
- * @param chain
- * @param obj
  */
 export declare function set<T>(chain: string, value: unknown, obj: IDictionary): void;

package/types/core/helpers/utils/utils.d.ts

@@ -3,12 +3,10 @@
  * 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 { CanPromise, IControlType, IViewBased, Nullable, IJodit, RejectablePromise } from '../../../types';
+import type { CanPromise, IControlType, IDictionary, IViewBased, Nullable, IJodit, RejectablePromise } from '../../../types';
 /**
  * Call function with parameters
  *
- * @param func
- * @param args
  * @example
  * ```js
  * const f = Math.random();
@@ -17,24 +15,28 @@ import type { CanPromise, IControlType, IViewBased, Nullable, IJodit, Rejectable
  */
 export declare function call<T extends any[], R>(func: (...args: T) => R, ...args: T): R;
 /**
- * Alias for `elm.getAttribute` but if set second argument `-{key}`
- * it will also check `data-{key}` attribute
- * if set `value` it is alias for setAttribute with same logic
- *
- * @param elm
- * @param key
- * @param [value]
+ * Get attribute
+ */
+export declare function attr(elm: Element, key: string): null | string;
+/**
+ * Remove attribute
+ */
+export declare function attr(elm: Element, key: string, value: null): null | string;
+/**
+ * Set attribute
+ */
+export declare function attr(elm: Element, key: string, value: string | number | boolean | undefined | null): null;
+/**
+ * Set or remove several attributes
  */
-export declare function attr(elm: Element | null, key: string, value?: string | number | boolean | null): null | string;
+export declare function attr(elm: Element, attributes: IDictionary<string | number | boolean | null>): null;
 /**
  * Mark element for debugging
- * @param elm
  */
 export declare function markOwner(jodit: IViewBased, elm: HTMLElement): void;
 export declare function callPromise(condition: CanPromise<unknown>, callback: () => CanPromise<any>): CanPromise<void>;
 /**
  * Reset Vanila JS native function
- * @param key
  * @example
  * ```js
  * reset('Array.from')(Set([1,2,3])) // [1, 2, 3]
@@ -43,16 +45,11 @@ export declare function callPromise(condition: CanPromise<unknown>, callback: ()
 export declare const reset: <T extends Function>(key: string) => Nullable<T>;
 /**
  * Allow load image in promise
- * @param src
- * @param jodit
  */
 export declare const loadImage: (src: string, jodit: IViewBased) => RejectablePromise<HTMLImageElement>;
 export declare const keys: (obj: object, own?: boolean) => string[];
 /**
  * Memorize last user chose
- * @param editor
- * @param _
- * @param control
  */
 export declare const memorizeExec: <T extends IJodit = IJodit>(editor: T, _: unknown, { control }: {
     control: IControlType<T, import("../../../types").IToolbarButton>;

package/types/core/plugin-system.d.ts

@@ -21,75 +21,44 @@ export declare class PluginSystem implements IPluginSystem {
     private items;
     /**
      * Add plugin in store
-     *
-     * @param name
-     * @param plugin
      */
     add(name: string, plugin: PluginType): void;
     /**
      * Get plugin from store
-     * @param name
      */
     get(name: string): PluginType | void;
     /**
      * Remove plugin from store
-     * @param name
      */
     remove(name: string): void;
     /**
      * Public method for async init all plugins
-     * @param jodit
      */
     init(jodit: IJodit): CanPromise<void>;
     /**
      * Plugin type has disabled requires
-     * @param disableList
-     * @param requires
      */
     private hasDisabledRequires;
     /**
      * Create instance of plugin
-     *
-     * @param jodit
-     * @param plugin
      */
     static makePluginInstance(jodit: IJodit, plugin: PluginType): PluginInstance;
     /**
      * Init plugin if it has not dependencies in another case wait requires plugins will be init
-     *
-     * @param jodit
-     * @param pluginName
-     * @param instance
-     * @param doneList
-     * @param promiseList
      */
     private initOrWait;
     /**
      * Destroy all plugins before - Jodit will be destroyed
-     *
-     * @param jodit
-     * @param plugins
      */
     private addListenerOnBeforeDestruct;
     /**
      * Download plugins
-     *
-     * @param jodit
-     * @param pluginList
      */
     private load;
-    /**
-     * @param jodit
-     * @param pluginName
-     */
     private static loadStyle;
     private static styles;
     /**
      * Call full url to the script or style file
-     *
-     * @param jodit
-     * @param name
-     * @param js
      */
     private static getFullUrl;
     private loadExtras;

package/types/core/request/ajax.d.ts

@@ -0,0 +1,26 @@
+/*!
+ * Jodit Editor (https://xdsoft.net/jodit/)
+ * 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 { IRequest, IViewBased, AjaxOptions, IAjax, RejectablePromise, IResponse } from '../../types';
+import './config';
+export declare class Ajax<T extends object = any> implements IAjax<T> {
+    readonly jodit: IViewBased;
+    static log: IRequest[];
+    private readonly xhr;
+    private __buildParams;
+    options: AjaxOptions;
+    get o(): this['options'];
+    /**
+     * Alias for this.jodit
+     */
+    get j(): this['jodit'];
+    abort(): Ajax;
+    private resolved;
+    private activated;
+    send(): RejectablePromise<IResponse<T>>;
+    prepareRequest(): IRequest;
+    constructor(jodit: IViewBased, options: Partial<AjaxOptions>);
+    destruct(): void;
+}

package/types/core/request/config.d.ts

@@ -0,0 +1,14 @@
+/*!
+ * Jodit Editor (https://xdsoft.net/jodit/)
+ * 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 { AjaxOptions } from '../../types';
+declare module '../../config' {
+    interface Config {
+        /**
+         * A set of key/value pairs that configure the Ajax request. All settings are optional
+         */
+        defaultAjaxOptions: AjaxOptions;
+    }
+}

package/{src/types/core.js → types/core/request/index.d.ts}

@@ -1,8 +1,7 @@
-"use strict";
 /*!
  * Jodit Editor (https://xdsoft.net/jodit/)
  * 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
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=core.js.map
+export * from './ajax';
+export * from './response';

package/types/core/request/response.d.ts

@@ -0,0 +1,16 @@
+/*!
+ * Jodit Editor (https://xdsoft.net/jodit/)
+ * 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 { IRequest, IResponse } from '../../types';
+export declare class Response<T> implements IResponse<T> {
+    readonly status: number;
+    readonly statusText: string;
+    readonly request: IRequest;
+    get url(): string;
+    private readonly body;
+    constructor(request: IRequest, status: number, statusText: string, body: string);
+    json(): Promise<T>;
+    text(): Promise<string>;
+}