jodit 3.8.8 → 3.9.2

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "jodit",
-	"version": "3.8.8",
+	"version": "3.9.2",
 	"description": "Jodit is awesome and usefully wysiwyg editor with filebrowser",
 	"main": "build/jodit.min.js",
 	"types": "./types/index.d.ts",

package/src/core/async.ts

@@ -201,7 +201,7 @@ export class Async implements IAsync {
 	promise<T>(
 		executor: (
 			resolve: (value: T | PromiseLike<T>) => void,
-			reject?: (reason?: any) => void
+			reject: (reason?: any) => void
 		) => void
 	): RejectablePromise<T> {
 		let rejectCallback: RejectablePromise<T>['rejectCallback'] = () => {};

package/src/core/constants.ts

@@ -162,3 +162,5 @@ export const BASE_PATH: string = ((): string => {
 
 	return window.location.href;
 })();
+
+export const TEMP_ATTR = 'data-jodit-temp';

package/src/core/dom.ts

@@ -30,6 +30,7 @@ import {
 	trim
 } from './helpers';
 import { Select } from './selection';
+import { TEMP_ATTR } from './constants';
 
 /**
  * Module for working with DOM
@@ -146,47 +147,6 @@ export class Dom {
 		}
 	}
 
-	/**
-	 * It goes through all the internal elements of the node, causing a callback function
-	 *
-	 * @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) {
-	 *  if (node.nodeType === Node.TEXT_NODE) {
-	 *      node.nodeValue = node.nodeValue.replace(Jodit.INVISIBLE_SPACE_REG_EX, '') // remove all of
-	 *      the text element codes invisible character
-	 *  }
-	 * });
-	 * ```
-	 */
-	static each(
-		elm: Node | HTMLElement,
-		callback: (node: Node) => void | boolean
-	): boolean {
-		let node: Node | null | false = elm.firstChild;
-
-		if (node) {
-			while (node) {
-				const next = Dom.next(node, Boolean, elm);
-
-				if (callback(node) === false) {
-					return false;
-				}
-
-				// inside callback - node could be removed
-				if (node.parentNode && !Dom.each(node, callback)) {
-					return false;
-				}
-
-				node = next;
-			}
-		}
-
-		return true;
-	}
-
 	/**
 	 * Call function for all nodes between `start` and `end`
 	 */
@@ -461,39 +421,25 @@ export class Dom {
 	/**
 	 * Find previous node
 	 */
-	static prev(
+	static prev<T extends Node = Node>(
 		node: Node,
 		condition: NodeCondition,
-		root: Node | HTMLElement | ParentNode,
+		root: HTMLElement,
 		withChild: boolean = true
-	): Nullable<Node> {
-		return Dom.find(
-			node,
-			condition,
-			root,
-			false,
-			'previousSibling',
-			withChild ? 'lastChild' : false
-		);
+	): Nullable<T> {
+		return Dom.find<T>(node, condition, root, false, withChild);
 	}
 
 	/**
 	 * Find next node what `condition(next) === true`
 	 */
-	static next(
+	static next<T extends Node = Node>(
 		node: Node,
 		condition: NodeCondition,
-		root: Node | HTMLElement | ParentNode,
+		root: HTMLElement,
 		withChild: boolean = true
-	): Nullable<Node> {
-		return Dom.find(
-			node,
-			condition,
-			root,
-			undefined,
-			undefined,
-			withChild ? 'firstChild' : false
-		);
+	): Nullable<T> {
+		return Dom.find<T>(node, condition, root, true, withChild);
 	}
 
 	static prevWithClass(
@@ -525,51 +471,122 @@ export class Dom {
 	/**
 	 * Find next/prev node what `condition(next) === true`
 	 */
-	static find(
+	static find<T extends Node = Node>(
 		node: Node,
 		condition: NodeCondition,
-		root: ParentNode | HTMLElement | Node,
-		recurse = false,
-		sibling: keyof Node = 'nextSibling',
-		child: keyof Node | false = 'firstChild'
-	): Nullable<Node> {
-		if (recurse && condition(node)) {
-			return node;
+		root: HTMLElement,
+		leftToRight: boolean = true,
+		withChild: boolean = true
+	): Nullable<T> {
+		const gen = this.nextGen(node, root, leftToRight, withChild);
+
+		let item = gen.next();
+
+		while (!item.done) {
+			if (condition(item.value)) {
+				return <T>item.value;
+			}
+
+			item = gen.next();
 		}
 
-		let start: Nullable<Node> = node,
-			next: Nullable<Node>;
+		return null;
+	}
+
+	/**
+	 * Find next/prev node what `condition(next) === true`
+	 */
+	static *nextGen(
+		start: Node,
+		root: HTMLElement,
+		leftToRight: boolean = true,
+		withChild: boolean = true
+	): Generator<Node> {
+		const stack: Node[] = [];
+
+		let currentNode = start;
 
 		do {
-			next = start[sibling] as Node;
+			let next = leftToRight
+				? currentNode.nextSibling
+				: currentNode.previousSibling;
 
-			if (condition(next)) {
-				return next ? next : null;
+			while (next) {
+				stack.unshift(next);
+				next = leftToRight ? next.nextSibling : next.previousSibling;
 			}
 
-			if (child && next && next[child]) {
-				const nextOne = Dom.find(
-					next[child] as Node,
-					condition,
-					next,
-					true,
-					sibling,
-					child
-				);
+			yield* this.runInStack(start, stack, leftToRight, withChild);
 
-				if (nextOne) {
-					return nextOne;
-				}
+			currentNode = <Node>currentNode.parentNode;
+		} while (currentNode !== root);
+
+		return null;
+	}
+
+	/**
+	 * It goes through all the internal elements of the node, causing a callback function
+	 *
+	 * @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) {
+	 *  if (node.nodeType === Node.TEXT_NODE) {
+	 *      node.nodeValue = node.nodeValue.replace(Jodit.INVISIBLE_SPACE_REG_EX, '') // remove all of
+	 *      the text element codes invisible character
+	 *  }
+	 * });
+	 * ```
+	 */
+	static each(
+		elm: Node,
+		callback: (node: Node) => void | boolean,
+		leftToRight: boolean = true
+	): boolean {
+		const gen = this.eachGen(elm, leftToRight);
+
+		let item = gen.next();
+
+		while (!item.done) {
+			if (callback(item.value) === false) {
+				return false;
 			}
 
-			if (!next) {
-				next = start.parentNode;
+			item = gen.next();
+		}
+
+		return true;
+	}
+
+	static eachGen(root: Node, leftToRight: boolean = true): Generator<Node> {
+		return this.runInStack(root, [root], leftToRight);
+	}
+
+	private static *runInStack(
+		start: Node,
+		stack: Node[],
+		leftToRight: boolean,
+		withChild: boolean = true
+	): Generator<Node> {
+		while (stack.length) {
+			const item = <Node>stack.pop();
+
+			if (start !== item) {
+				yield item;
 			}
 
-			start = next;
-		} while (start && start !== root);
+			if (withChild) {
+				let child = leftToRight ? item.lastChild : item.firstChild;
 
-		return null;
+				while (child) {
+					stack.push(child);
+					child = leftToRight
+						? child.previousSibling
+						: child.nextSibling;
+				}
+			}
+		}
 	}
 
 	/**
@@ -948,7 +965,7 @@ export class Dom {
 		attributes?: IDictionary
 	): K {
 		attributes && attr(element, attributes);
-		attr(element, 'data-jodit-temp', true);
+		attr(element, TEMP_ATTR, true);
 		return element;
 	}
 
@@ -960,10 +977,7 @@ export class Dom {
 			return false;
 		}
 
-		return (
-			Select.isMarker(element) ||
-			attr(element, 'data-jodit-temp') === 'true'
-		);
+		return Select.isMarker(element) || attr(element, TEMP_ATTR) === 'true';
 	}
 
 	/**
@@ -980,6 +994,6 @@ export class Dom {
 	 * Get temporary list
 	 */
 	static temporaryList(root: HTMLElement): HTMLElement[] {
-		return $$('[data-jodit-temp]', root);
+		return $$(`[${TEMP_ATTR}]`, root);
 	}
 }

package/src/core/events/{events-native.ts → event-emitter.ts}

@@ -4,14 +4,11 @@
  * Copyright (c) 2013-2021 Valeriy Chupurnov. All rights reserved. https://xdsoft.net
  */
 
-/**
- * The module editor's event manager
- */
-
+// eslint-disable-next-line max-classes-per-file
 import type {
 	CallbackFunction,
 	EventHandlerBlock,
-	IEventsNative
+	IEventEmitter
 } from '../../types';
 import { defaultNameSpace, EventHandlersStore } from './store';
 import { isString } from '../helpers/checker/is-string';
@@ -19,7 +16,10 @@ import { isFunction } from '../helpers/checker/is-function';
 import { isArray } from '../helpers/checker/is-array';
 import { error } from '../helpers/type';
 
-export class EventsNative implements IEventsNative {
+/**
+ * The module editor's event manager
+ */
+export class EventEmitter implements IEventEmitter {
 	private mutedEvents: Set<string> = new Set();
 
 	mute(event?: string): this {
@@ -40,7 +40,7 @@ export class EventsNative implements IEventsNative {
 		return this;
 	}
 
-	readonly __key: string = '__JoditEventsNativeNamespaces';
+	readonly __key: string = '__JoditEventEmitterNamespaces';
 
 	private doc: Document = document;
 
@@ -265,7 +265,7 @@ export class EventsNative implements IEventsNative {
 		}
 
 		const isDOMElement = isFunction((subject as any).addEventListener),
-			self: EventsNative = this;
+			self: EventEmitter = this;
 
 		let syntheticCallback: CallbackFunction = function (
 			this: any,
@@ -564,7 +564,7 @@ export class EventsNative implements IEventsNative {
 	 * ```
 	 *  or you can trigger native browser listener
 	 * ```javascript
-	 *  var events = new Jodit.modules.EventsNative();
+	 *  var events = new Jodit.modules.EventEmitter();
 	 *  events.on(document.body, 'click',function (event) {
 	 *      alert('click on ' + event.target.id );
 	 *  });
@@ -697,3 +697,8 @@ export class EventsNative implements IEventsNative {
 		delete (this as any)[this.__key];
 	}
 }
+
+/**
+ * @deprecated Use `EventEmitter` instead
+ */
+export class EventsNative extends EventEmitter implements IEventEmitter {}

package/src/core/events/index.ts

@@ -4,6 +4,6 @@
  * Copyright (c) 2013-2021 Valeriy Chupurnov. All rights reserved. https://xdsoft.net
  */
 
-export * from './events-native';
+export * from './event-emitter';
 export * from './observe-object';
 export * from './store';

package/src/core/global.ts

@@ -24,7 +24,7 @@ import {
 	kebabCase
 } from './helpers/';
 
-import { EventsNative } from './events';
+import { EventEmitter } from './events';
 
 export const instances: IDictionary<IJodit> = {};
 
@@ -124,4 +124,4 @@ export function getContainer<T extends HTMLTagNames = HTMLTagNames>(
 /**
  * Global event emitter
  */
-export const eventEmitter = new EventsNative();
+export const eventEmitter = new EventEmitter();

package/src/core/helpers/array/to-array.ts

@@ -17,5 +17,6 @@ export const toArray = function toArray<T extends typeof Array.from>(
 	const func = isNativeFunction(Array.from)
 		? Array.from
 		: reset<typeof Array.from>('Array.from') ?? Array.from;
+
 	return func.apply(Array, args) as ReturnType<T>;
 } as typeof Array.from;

package/src/core/helpers/data-bind.ts

@@ -4,7 +4,7 @@
  * Copyright (c) 2013-2021 Valeriy Chupurnov. All rights reserved. https://xdsoft.net
  */
 
-import type { IEventsNative, IViewComponent, Nullable } from '../../types';
+import type { IEventEmitter, IViewComponent, Nullable } from '../../types';
 import { ViewComponent } from '../component';
 import { isViewObject } from './checker';
 
@@ -21,7 +21,7 @@ export const dataBind = <T = any>(
 		itemStore = {};
 		store.set(elm, itemStore);
 
-		let e: Nullable<IEventsNative> = null;
+		let e: Nullable<IEventEmitter> = null;
 
 		if (elm instanceof ViewComponent) {
 			e = (elm as IViewComponent).j.e;

package/src/core/helpers/utils/utils.ts

@@ -40,21 +40,37 @@ export function call<T extends any[], 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
+ * Get attribute
  */
 export function attr(elm: Element, key: string): null | string;
+
+/**
+ * Remove attribute
+ */
+export function attr(elm: Element, key: string, value: null): null | string;
+
+/**
+ * Set attribute
+ */
 export function attr(
 	elm: Element,
 	key: string,
-	value: string | number | boolean | null | undefined
+	value: string | number | boolean | undefined | null
 ): null;
+
+/**
+ * Set or remove several attributes
+ */
 export function attr(
 	elm: Element,
 	attributes: IDictionary<string | number | boolean | null>
 ): null;
 
+/**
+ * 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
+ */
 export function attr(
 	elm: Element,
 	keyOrAttributes: string | IDictionary<string | number | boolean | null>,

package/src/core/request/ajax.ts

@@ -0,0 +1,212 @@
+/*!
+ * 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 {
+	IDictionary,
+	IRequest,
+	IViewBased,
+	AjaxOptions,
+	IAjax,
+	RejectablePromise,
+	IResponse
+} from '../../types';
+
+import { Config } from '../../config';
+
+import {
+	error,
+	isPlainObject,
+	parseQuery,
+	buildQuery,
+	isString,
+	isFunction,
+	ConfigProto
+} from '../helpers';
+import { Response } from './response';
+
+import './config';
+
+export class Ajax<T extends object = any> implements IAjax<T> {
+	static log: IRequest[] = [];
+
+	private readonly xhr!: XMLHttpRequest;
+
+	private __buildParams(
+		obj: string | IDictionary<string | object> | FormData,
+		prefix?: string
+	): string | FormData {
+		if (isFunction(this.o.queryBuild)) {
+			return this.o.queryBuild.call(this, obj, prefix);
+		}
+
+		if (
+			isString(obj) ||
+			((this.j.ow as any).FormData &&
+				obj instanceof (this.j.ow as any).FormData)
+		) {
+			return obj as string | FormData;
+		}
+
+		return buildQuery(obj);
+	}
+
+	options: AjaxOptions;
+	get o(): this['options'] {
+		return this.options;
+	}
+
+	/**
+	 * Alias for this.jodit
+	 */
+	get j(): this['jodit'] {
+		return this.jodit;
+	}
+
+	abort(): Ajax {
+		try {
+			this.xhr.abort();
+		} catch {}
+
+		return this;
+	}
+
+	private resolved = false;
+
+	private activated = false;
+
+	send(): RejectablePromise<IResponse<T>> {
+		this.activated = true;
+
+		const { xhr, o } = this;
+
+		const request = this.prepareRequest();
+
+		return this.j.async.promise((resolve, reject) => {
+			const onReject = () => {
+				reject(error('Connection error'));
+			};
+
+			const onResolve = () => {
+				this.resolved = true;
+
+				resolve(
+					new Response<T>(
+						request,
+						xhr.status,
+						xhr.statusText,
+						xhr.responseText
+					)
+				);
+			};
+
+			xhr.onabort = onReject;
+			xhr.onerror = onReject;
+			xhr.ontimeout = onReject;
+
+			xhr.onload = onResolve;
+
+			xhr.onprogress = (e): void => {
+				let percentComplete = 0;
+
+				if (e.lengthComputable) {
+					percentComplete = (e.loaded / e.total) * 100;
+				}
+
+				this.options.onProgress?.(percentComplete);
+			};
+
+			xhr.onreadystatechange = () => {
+				this.options.onProgress?.(10);
+
+				if (xhr.readyState === XMLHttpRequest.DONE) {
+					if (o.successStatuses.includes(xhr.status)) {
+						onResolve();
+					} else {
+						reject(error(xhr.statusText || 'Connection error'));
+					}
+				}
+			};
+
+			xhr.withCredentials = o.withCredentials ?? false;
+
+			const { url, data, method } = request;
+
+			xhr.open(method, url, true);
+
+			if (o.contentType && xhr.setRequestHeader) {
+				xhr.setRequestHeader('Content-type', o.contentType);
+			}
+
+			const { headers } = o;
+
+			if (headers && xhr.setRequestHeader) {
+				Object.keys(headers).forEach(key => {
+					xhr.setRequestHeader(key, headers[key]);
+				});
+			}
+
+			// IE
+			this.j.async.setTimeout(() => {
+				xhr.send(data ? this.__buildParams(data) : undefined);
+			}, 0);
+		});
+	}
+
+	prepareRequest(): IRequest {
+		if (!this.o.url) {
+			throw error('Need URL for AJAX request');
+		}
+
+		let url: string = this.o.url;
+
+		const data = this.o.data;
+		const method = (this.o.method || 'get').toLowerCase();
+
+		if (method === 'get' && data && isPlainObject(data)) {
+			const qIndex = url.indexOf('?');
+
+			if (qIndex !== -1) {
+				const urlData = parseQuery(url);
+
+				url =
+					url.substr(0, qIndex) +
+					'?' +
+					buildQuery({ ...urlData, ...(data as IDictionary) });
+			} else {
+				url += '?' + buildQuery(this.o.data as IDictionary);
+			}
+		}
+
+		const request = {
+			url,
+			method,
+			data
+		};
+
+		Ajax.log.splice(100);
+		Ajax.log.push(request);
+
+		return request;
+	}
+
+	constructor(readonly jodit: IViewBased, options: Partial<AjaxOptions>) {
+		this.options = ConfigProto(
+			options || {},
+			Config.prototype.defaultAjaxOptions
+		) as AjaxOptions;
+
+		this.xhr = this.o.xhr ? this.o.xhr() : new XMLHttpRequest();
+
+		jodit && jodit.e && jodit.e.on('beforeDestruct', () => this.destruct());
+	}
+
+	destruct(): void {
+		if (this.activated && !this.resolved) {
+			this.abort();
+			this.resolved = true;
+		}
+	}
+}