@ckeditor/ckeditor5-utils 35.0.1 → 35.2.0

package/src/observablemixin.js

@@ -2,11 +2,11 @@
  * @license Copyright (c) 2003-2022, CKSource Holding sp. z o.o. All rights reserved.
  * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
  */
-/* eslint-disable @typescript-eslint/unified-signatures */
+/* eslint-disable @typescript-eslint/unified-signatures, new-cap */
 /**
  * @module utils/observablemixin
  */
-import EmitterMixin from './emittermixin';
+import { Emitter } from './emittermixin';
 import CKEditorError from './ckeditorerror';
 import { isObject } from 'lodash-es';
 const observablePropertiesSymbol = Symbol('observableProperties');
@@ -27,217 +27,216 @@ const decoratedOriginal = Symbol('decoratedOriginal');
  * @mixes module:utils/emittermixin~EmitterMixin
  * @implements module:utils/observablemixin~Observable
  */
-const ObservableMixin = {
-    /**
-     * @inheritDoc
-     */
-    set(name, value) {
-        // If the first parameter is an Object, iterate over its properties.
-        if (isObject(name)) {
-            Object.keys(name).forEach(property => {
-                this.set(property, name[property]);
-            }, this);
-            return;
-        }
-        initObservable(this);
-        const properties = this[observablePropertiesSymbol];
-        if ((name in this) && !properties.has(name)) {
-            /**
-             * Cannot override an existing property.
-             *
-             * This error is thrown when trying to {@link ~Observable#set set} a property with
-             * a name of an already existing property. For example:
-             *
-             *		let observable = new Model();
-             *		observable.property = 1;
-             *		observable.set( 'property', 2 );			// throws
-             *
-             *		observable.set( 'property', 1 );
-             *		observable.set( 'property', 2 );			// ok, because this is an existing property.
-             *
-             * @error observable-set-cannot-override
-             */
-            throw new CKEditorError('observable-set-cannot-override', this);
-        }
-        Object.defineProperty(this, name, {
-            enumerable: true,
-            configurable: true,
-            get() {
-                return properties.get(name);
-            },
-            set(value) {
-                const oldValue = properties.get(name);
-                // Fire `set` event before the new value will be set to make it possible
-                // to override observable property without affecting `change` event.
-                // See https://github.com/ckeditor/ckeditor5-utils/issues/171.
-                let newValue = this.fire('set:' + name, name, value, oldValue);
-                if (newValue === undefined) {
-                    newValue = value;
-                }
-                // Allow undefined as an initial value like A.define( 'x', undefined ) (#132).
-                // Note: When properties map has no such own property, then its value is undefined.
-                if (oldValue !== newValue || !properties.has(name)) {
-                    properties.set(name, newValue);
-                    this.fire('change:' + name, name, newValue, oldValue);
-                }
+export default function ObservableMixin(base) {
+    class Mixin extends base {
+        set(name, value) {
+            // If the first parameter is an Object, iterate over its properties.
+            if (isObject(name)) {
+                Object.keys(name).forEach(property => {
+                    this.set(property, name[property]);
+                }, this);
+                return;
             }
-        });
-        this[name] = value;
-    },
-    /**
-     * @inheritDoc
-     */
-    bind(...bindProperties) {
-        if (!bindProperties.length || !isStringArray(bindProperties)) {
-            /**
-             * All properties must be strings.
-             *
-             * @error observable-bind-wrong-properties
-             */
-            throw new CKEditorError('observable-bind-wrong-properties', this);
-        }
-        if ((new Set(bindProperties)).size !== bindProperties.length) {
-            /**
-             * Properties must be unique.
-             *
-             * @error observable-bind-duplicate-properties
-             */
-            throw new CKEditorError('observable-bind-duplicate-properties', this);
-        }
-        initObservable(this);
-        const boundProperties = this[boundPropertiesSymbol];
-        bindProperties.forEach(propertyName => {
-            if (boundProperties.has(propertyName)) {
+            initObservable(this);
+            const properties = this[observablePropertiesSymbol];
+            if ((name in this) && !properties.has(name)) {
                 /**
-                 * Cannot bind the same property more than once.
+                 * Cannot override an existing property.
+                 *
+                 * This error is thrown when trying to {@link ~Observable#set set} a property with
+                 * a name of an already existing property. For example:
+                 *
+                 *		let observable = new Model();
+                 *		observable.property = 1;
+                 *		observable.set( 'property', 2 );			// throws
+                 *
+                 *		observable.set( 'property', 1 );
+                 *		observable.set( 'property', 2 );			// ok, because this is an existing property.
                  *
-                 * @error observable-bind-rebind
+                 * @error observable-set-cannot-override
                  */
-                throw new CKEditorError('observable-bind-rebind', this);
+                throw new CKEditorError('observable-set-cannot-override', this);
             }
-        });
-        const bindings = new Map();
-        // @typedef {Object} Binding
-        // @property {Array} property Property which is bound.
-        // @property {Array} to Array of observable–property components of the binding (`{ observable: ..., property: .. }`).
-        // @property {Array} callback A function which processes `to` components.
-        bindProperties.forEach(a => {
-            const binding = { property: a, to: [] };
-            boundProperties.set(a, binding);
-            bindings.set(a, binding);
-        });
-        // @typedef {Object} BindChain
-        // @property {Function} to See {@link ~ObservableMixin#_bindTo}.
-        // @property {Function} toMany See {@link ~ObservableMixin#_bindToMany}.
-        // @property {module:utils/observablemixin~Observable} _observable The observable which initializes the binding.
-        // @property {Array} _bindProperties Array of `_observable` properties to be bound.
-        // @property {Array} _to Array of `to()` observable–properties (`{ observable: toObservable, properties: ...toProperties }`).
-        // @property {Map} _bindings Stores bindings to be kept in
-        // {@link ~ObservableMixin#_boundProperties}/{@link ~ObservableMixin#_boundObservables}
-        // initiated in this binding chain.
-        return {
-            to: bindTo,
-            toMany: bindToMany,
-            _observable: this,
-            _bindProperties: bindProperties,
-            _to: [],
-            _bindings: bindings
-        };
-    },
-    /**
-     * @inheritDoc
-     */
-    unbind(...unbindProperties) {
-        // Nothing to do here if not inited yet.
-        if (!(this[observablePropertiesSymbol])) {
-            return;
+            Object.defineProperty(this, name, {
+                enumerable: true,
+                configurable: true,
+                get() {
+                    return properties.get(name);
+                },
+                set(value) {
+                    const oldValue = properties.get(name);
+                    // Fire `set` event before the new value will be set to make it possible
+                    // to override observable property without affecting `change` event.
+                    // See https://github.com/ckeditor/ckeditor5-utils/issues/171.
+                    let newValue = this.fire(`set:${name}`, name, value, oldValue);
+                    if (newValue === undefined) {
+                        newValue = value;
+                    }
+                    // Allow undefined as an initial value like A.define( 'x', undefined ) (#132).
+                    // Note: When properties map has no such own property, then its value is undefined.
+                    if (oldValue !== newValue || !properties.has(name)) {
+                        properties.set(name, newValue);
+                        this.fire(`change:${name}`, name, newValue, oldValue);
+                    }
+                }
+            });
+            this[name] = value;
         }
-        const boundProperties = this[boundPropertiesSymbol];
-        const boundObservables = this[boundObservablesSymbol];
-        if (unbindProperties.length) {
-            if (!isStringArray(unbindProperties)) {
+        bind(...bindProperties) {
+            if (!bindProperties.length || !isStringArray(bindProperties)) {
+                /**
+                 * All properties must be strings.
+                 *
+                 * @error observable-bind-wrong-properties
+                 */
+                throw new CKEditorError('observable-bind-wrong-properties', this);
+            }
+            if ((new Set(bindProperties)).size !== bindProperties.length) {
                 /**
-                 * Properties must be strings.
+                 * Properties must be unique.
                  *
-                 * @error observable-unbind-wrong-properties
+                 * @error observable-bind-duplicate-properties
                  */
-                throw new CKEditorError('observable-unbind-wrong-properties', this);
+                throw new CKEditorError('observable-bind-duplicate-properties', this);
             }
-            unbindProperties.forEach(propertyName => {
-                const binding = boundProperties.get(propertyName);
-                // Nothing to do if the binding is not defined
-                if (!binding) {
-                    return;
+            initObservable(this);
+            const boundProperties = this[boundPropertiesSymbol];
+            bindProperties.forEach(propertyName => {
+                if (boundProperties.has(propertyName)) {
+                    /**
+                     * Cannot bind the same property more than once.
+                     *
+                     * @error observable-bind-rebind
+                     */
+                    throw new CKEditorError('observable-bind-rebind', this);
                 }
-                binding.to.forEach(([toObservable, toProperty]) => {
-                    const toProperties = boundObservables.get(toObservable);
-                    const toPropertyBindings = toProperties[toProperty];
-                    toPropertyBindings.delete(binding);
-                    if (!toPropertyBindings.size) {
-                        delete toProperties[toProperty];
-                    }
-                    if (!Object.keys(toProperties).length) {
-                        boundObservables.delete(toObservable);
-                        this.stopListening(toObservable, 'change');
-                    }
-                });
-                boundProperties.delete(propertyName);
             });
-        }
-        else {
-            boundObservables.forEach((bindings, boundObservable) => {
-                this.stopListening(boundObservable, 'change');
+            const bindings = new Map();
+            // @typedef {Object} Binding
+            // @property {Array} property Property which is bound.
+            // @property {Array} to Array of observable–property components of the binding (`{ observable: ..., property: .. }`).
+            // @property {Array} callback A function which processes `to` components.
+            bindProperties.forEach(a => {
+                const binding = { property: a, to: [] };
+                boundProperties.set(a, binding);
+                bindings.set(a, binding);
             });
-            boundObservables.clear();
-            boundProperties.clear();
+            // @typedef {Object} BindChain
+            // @property {Function} to See {@link ~ObservableMixin#_bindTo}.
+            // @property {Function} toMany See {@link ~ObservableMixin#_bindToMany}.
+            // @property {module:utils/observablemixin~Observable} _observable The observable which initializes the binding.
+            // @property {Array} _bindProperties Array of `_observable` properties to be bound.
+            // @property {Array} _to Array of `to()` observable–properties (`{ observable: toObservable, properties: ...toProperties }`).
+            // @property {Map} _bindings Stores bindings to be kept in
+            // {@link ~ObservableMixin#_boundProperties}/{@link ~ObservableMixin#_boundObservables}
+            // initiated in this binding chain.
+            return {
+                to: bindTo,
+                toMany: bindToMany,
+                _observable: this,
+                _bindProperties: bindProperties,
+                _to: [],
+                _bindings: bindings
+            };
         }
-    },
-    /**
-     * @inheritDoc
-     */
-    decorate(methodName) {
-        initObservable(this);
-        const originalMethod = this[methodName];
-        if (!originalMethod) {
-            /**
-             * Cannot decorate an undefined method.
-             *
-             * @error observablemixin-cannot-decorate-undefined
-             * @param {Object} object The object which method should be decorated.
-             * @param {String} methodName Name of the method which does not exist.
-             */
-            throw new CKEditorError('observablemixin-cannot-decorate-undefined', this, { object: this, methodName });
+        unbind(...unbindProperties) {
+            // Nothing to do here if not inited yet.
+            if (!(this[observablePropertiesSymbol])) {
+                return;
+            }
+            const boundProperties = this[boundPropertiesSymbol];
+            const boundObservables = this[boundObservablesSymbol];
+            if (unbindProperties.length) {
+                if (!isStringArray(unbindProperties)) {
+                    /**
+                     * Properties must be strings.
+                     *
+                     * @error observable-unbind-wrong-properties
+                     */
+                    throw new CKEditorError('observable-unbind-wrong-properties', this);
+                }
+                unbindProperties.forEach(propertyName => {
+                    const binding = boundProperties.get(propertyName);
+                    // Nothing to do if the binding is not defined
+                    if (!binding) {
+                        return;
+                    }
+                    binding.to.forEach(([toObservable, toProperty]) => {
+                        const toProperties = boundObservables.get(toObservable);
+                        const toPropertyBindings = toProperties[toProperty];
+                        toPropertyBindings.delete(binding);
+                        if (!toPropertyBindings.size) {
+                            delete toProperties[toProperty];
+                        }
+                        if (!Object.keys(toProperties).length) {
+                            boundObservables.delete(toObservable);
+                            this.stopListening(toObservable, 'change');
+                        }
+                    });
+                    boundProperties.delete(propertyName);
+                });
+            }
+            else {
+                boundObservables.forEach((bindings, boundObservable) => {
+                    this.stopListening(boundObservable, 'change');
+                });
+                boundObservables.clear();
+                boundProperties.clear();
+            }
         }
-        this.on(methodName, (evt, args) => {
-            evt.return = originalMethod.apply(this, args);
-        });
-        this[methodName] = function (...args) {
-            return this.fire(methodName, args);
-        };
-        this[methodName][decoratedOriginal] = originalMethod;
-        if (!this[decoratedMethods]) {
-            this[decoratedMethods] = [];
+        decorate(methodName) {
+            initObservable(this);
+            const originalMethod = this[methodName];
+            if (!originalMethod) {
+                /**
+                 * Cannot decorate an undefined method.
+                 *
+                 * @error observablemixin-cannot-decorate-undefined
+                 * @param {Object} object The object which method should be decorated.
+                 * @param {String} methodName Name of the method which does not exist.
+                 */
+                throw new CKEditorError('observablemixin-cannot-decorate-undefined', this, { object: this, methodName });
+            }
+            this.on(methodName, (evt, args) => {
+                evt.return = originalMethod.apply(this, args);
+            });
+            this[methodName] = function (...args) {
+                return this.fire(methodName, args);
+            };
+            this[methodName][decoratedOriginal] = originalMethod;
+            if (!this[decoratedMethods]) {
+                this[decoratedMethods] = [];
+            }
+            this[decoratedMethods].push(methodName);
         }
-        this[decoratedMethods].push(methodName);
-    },
-    ...EmitterMixin
-};
-// Override the EmitterMixin stopListening method to be able to clean (and restore) decorated methods.
-// This is needed in case of:
-//  1. Have x.foo() decorated.
-//  2. Call x.stopListening()
-//  3. Call x.foo(). Problem: nothing happens (the original foo() method is not executed)
-ObservableMixin.stopListening = function (emitter, event, callback) {
-    // Removing all listeners so let's clean the decorated methods to the original state.
-    if (!emitter && this[decoratedMethods]) {
-        for (const methodName of this[decoratedMethods]) {
-            this[methodName] = this[methodName][decoratedOriginal];
+        // Override the EmitterMixin stopListening method to be able to clean (and restore) decorated methods.
+        // This is needed in case of:
+        //  1. Have x.foo() decorated.
+        //  2. Call x.stopListening()
+        //  3. Call x.foo(). Problem: nothing happens (the original foo() method is not executed)
+        stopListening(emitter, event, callback) {
+            // Removing all listeners so let's clean the decorated methods to the original state.
+            if (!emitter && this[decoratedMethods]) {
+                for (const methodName of this[decoratedMethods]) {
+                    this[methodName] = this[methodName][decoratedOriginal];
+                }
+                delete this[decoratedMethods];
+            }
+            Emitter.prototype.stopListening.call(this, emitter, event, callback);
         }
-        delete this[decoratedMethods];
     }
-    EmitterMixin.stopListening.call(this, emitter, event, callback);
-};
-export default ObservableMixin;
+    return Mixin;
+}
+export const Observable = ObservableMixin(Emitter);
+// Backward compatibility with `mix`
+([
+    'set', 'bind', 'unbind', 'decorate',
+    'on', 'once', 'off', 'listenTo',
+    'stopListening', 'fire', 'delegate', 'stopDelegating',
+    '_addEventListener', '_removeEventListener'
+]).forEach(key => {
+    ObservableMixin[key] = Observable.prototype[key];
+});
 // Init symbol properties needed for the observable mechanism to work.
 //
 // @private

package/src/splicearray.js

@@ -0,0 +1,39 @@
+/**
+ * @license Copyright (c) 2003-2022, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @module utils/splicearray
+ */
+const BIG_CHUNK_SIZE = 10000;
+/**
+ * Splices one array into another. To be used instead of `Array.prototype.splice` as the latter may
+ * throw "Maximum call stack size exceeded" when passed huge number of items to insert.
+ *
+ * Note: in contrary to Array.splice, this function does not modify the original `target`.
+ *
+ * 		spliceArray( [ 1, 2 ], [ 3, 4 ], 0, 0 );		// [ 3, 4, 1, 2 ]
+ * 		spliceArray( [ 1, 2 ], [ 3, 4 ], 1, 1 );		// [ 1, 3, 4 ]
+ * 		spliceArray( [ 1, 2 ], [ 3, 4 ], 1, 0 );		// [ 1, 3, 4, 2 ]
+ * 		spliceArray( [ 1, 2 ], [ 3, 4 ], 2, 0 );		// [ 1, 2, 3, 4 ]
+ * 		spliceArray( [ 1, 2 ], [], 0, 1 );				// [ 2 ]
+ *
+ * @private
+ * @param {Array} target Array to be spliced.
+ * @param {Array} source Array of elements to be inserted to target.
+ * @param {Number} start Index at which nodes should be inserted/removed.
+ * @param {Number} count Number of items.
+ *
+ * @returns {Array} New spliced array.
+ */
+export default function spliceArray(target, source, start, count) {
+    // In case of performance problems, see: https://github.com/ckeditor/ckeditor5/pull/12429/files#r965850568
+    if (Math.max(source.length, target.length) > BIG_CHUNK_SIZE) {
+        return target.slice(0, start).concat(source).concat(target.slice(start + count, target.length));
+    }
+    else {
+        const newTarget = Array.from(target);
+        newTarget.splice(start, count, ...source);
+        return newTarget;
+    }
+}

package/src/translation-service.js

@@ -2,15 +2,15 @@
  * @license Copyright (c) 2003-2022, CKSource Holding sp. z o.o. All rights reserved.
  * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
  */
-/* globals window */
 /* eslint-disable no-var */
 /**
  * @module utils/translation-service
  */
 import CKEditorError from './ckeditorerror';
+import global from './dom/global';
 /* istanbul ignore else */
-if (!window.CKEDITOR_TRANSLATIONS) {
-    window.CKEDITOR_TRANSLATIONS = {};
+if (!global.window.CKEDITOR_TRANSLATIONS) {
+    global.window.CKEDITOR_TRANSLATIONS = {};
 }
 /**
  * Adds translations to existing ones or overrides the existing translations. These translations will later
@@ -64,15 +64,15 @@ if (!window.CKEDITOR_TRANSLATIONS) {
  * the one below:
  *
  *		function addTranslations( language, translations, getPluralForm ) {
- *			if ( !window.CKEDITOR_TRANSLATIONS ) {
- *				window.CKEDITOR_TRANSLATIONS = {};
+ *			if ( !global.window.CKEDITOR_TRANSLATIONS ) {
+ *				global.window.CKEDITOR_TRANSLATIONS = {};
  *			}
 
- *			if ( !window.CKEDITOR_TRANSLATIONS[ language ] ) {
- *				window.CKEDITOR_TRANSLATIONS[ language ] = {};
+ *			if ( !global.window.CKEDITOR_TRANSLATIONS[ language ] ) {
+ *				global.window.CKEDITOR_TRANSLATIONS[ language ] = {};
  *			}
  *
- *			const languageTranslations = window.CKEDITOR_TRANSLATIONS[ language ];
+ *			const languageTranslations = global.window.CKEDITOR_TRANSLATIONS[ language ];
  *
  * 			languageTranslations.dictionary = languageTranslations.dictionary || {};
  * 			languageTranslations.getPluralForm = getPluralForm || languageTranslations.getPluralForm;
@@ -88,10 +88,10 @@ if (!window.CKEDITOR_TRANSLATIONS) {
  * @param {Function} [getPluralForm] A function that returns the plural form index (a number).
  */
 export function add(language, translations, getPluralForm) {
-    if (!window.CKEDITOR_TRANSLATIONS[language]) {
-        window.CKEDITOR_TRANSLATIONS[language] = {};
+    if (!global.window.CKEDITOR_TRANSLATIONS[language]) {
+        global.window.CKEDITOR_TRANSLATIONS[language] = {};
     }
-    const languageTranslations = window.CKEDITOR_TRANSLATIONS[language];
+    const languageTranslations = global.window.CKEDITOR_TRANSLATIONS[language];
     languageTranslations.dictionary = languageTranslations.dictionary || {};
     languageTranslations.getPluralForm = getPluralForm || languageTranslations.getPluralForm;
     Object.assign(languageTranslations.dictionary, translations);
@@ -142,7 +142,7 @@ export function _translate(language, message, quantity = 1) {
     if (numberOfLanguages === 1) {
         // Override the language to the only supported one.
         // This can't be done in the `Locale` class, because the translations comes after the `Locale` class initialization.
-        language = Object.keys(window.CKEDITOR_TRANSLATIONS)[0];
+        language = Object.keys(global.window.CKEDITOR_TRANSLATIONS)[0];
     }
     const messageId = message.id || message.string;
     if (numberOfLanguages === 0 || !hasTranslation(language, messageId)) {
@@ -152,8 +152,8 @@ export function _translate(language, message, quantity = 1) {
         }
         return message.string;
     }
-    const dictionary = window.CKEDITOR_TRANSLATIONS[language].dictionary;
-    const getPluralForm = window.CKEDITOR_TRANSLATIONS[language].getPluralForm || (n => n === 1 ? 0 : 1);
+    const dictionary = global.window.CKEDITOR_TRANSLATIONS[language].dictionary;
+    const getPluralForm = global.window.CKEDITOR_TRANSLATIONS[language].getPluralForm || (n => n === 1 ? 0 : 1);
     const translation = dictionary[messageId];
     if (typeof translation === 'string') {
         return translation;
@@ -168,13 +168,13 @@ export function _translate(language, message, quantity = 1) {
  * @protected
  */
 export function _clear() {
-    window.CKEDITOR_TRANSLATIONS = {};
+    global.window.CKEDITOR_TRANSLATIONS = {};
 }
 // Checks whether the dictionary exists and translation in that dictionary exists.
 function hasTranslation(language, messageId) {
-    return (!!window.CKEDITOR_TRANSLATIONS[language] &&
-        !!window.CKEDITOR_TRANSLATIONS[language].dictionary[messageId]);
+    return (!!global.window.CKEDITOR_TRANSLATIONS[language] &&
+        !!global.window.CKEDITOR_TRANSLATIONS[language].dictionary[messageId]);
 }
 function getNumberOfLanguages() {
-    return Object.keys(window.CKEDITOR_TRANSLATIONS).length;
+    return Object.keys(global.window.CKEDITOR_TRANSLATIONS).length;
 }

package/src/version.js

@@ -7,7 +7,7 @@
  */
 /* globals window, global */
 import CKEditorError from './ckeditorerror';
-const version = '35.0.1';
+const version = '35.2.0';
 export default version;
 /* istanbul ignore next */
 const windowOrGlobal = typeof window === 'object' ? window : global;