@ckeditor/ckeditor5-core 43.3.1-alpha.0 → 44.0.0-alpha.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ckeditor/ckeditor5-core",
-  "version": "43.3.1-alpha.0",
+  "version": "44.0.0-alpha.0",
   "description": "The core architecture of CKEditor 5 – the best browser-based rich text editor.",
   "keywords": [
     "wysiwyg",
@@ -24,9 +24,9 @@
   "type": "module",
   "main": "src/index.js",
   "dependencies": {
-    "@ckeditor/ckeditor5-engine": "43.3.1-alpha.0",
-    "@ckeditor/ckeditor5-utils": "43.3.1-alpha.0",
-    "@ckeditor/ckeditor5-watchdog": "43.3.1-alpha.0",
+    "@ckeditor/ckeditor5-engine": "44.0.0-alpha.0",
+    "@ckeditor/ckeditor5-utils": "44.0.0-alpha.0",
+    "@ckeditor/ckeditor5-watchdog": "44.0.0-alpha.0",
     "lodash-es": "4.17.21"
   },
   "author": "CKSource (http://cksource.com/)",

package/src/editor/editor.d.ts

@@ -2,9 +2,6 @@
  * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
  * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
  */
-/**
- * @module core/editor/editor
- */
 import { Config, type Locale, type LocaleTranslate } from '@ckeditor/ckeditor5-utils';
 import { Conversion, DataController, EditingController, Model } from '@ckeditor/ckeditor5-engine';
 import type { EditorUI } from '@ckeditor/ckeditor5-ui';
@@ -16,6 +13,9 @@ import EditingKeystrokeHandler from '../editingkeystrokehandler.js';
 import Accessibility from '../accessibility.js';
 import type { LoadedPlugins, PluginConstructor } from '../plugin.js';
 import type { EditorConfig } from './editorconfig.js';
+declare global {
+    var CKEDITOR_GLOBAL_LICENSE_KEY: string | undefined;
+}
 declare const Editor_base: {
     new (): import("@ckeditor/ckeditor5-utils").Observable;
     prototype: import("@ckeditor/ckeditor5-utils").Observable;
@@ -39,6 +39,10 @@ declare const Editor_base: {
  * (as most editor implementations do).
  */
 export default abstract class Editor extends /* #__PURE__ */ Editor_base {
+    /**
+     * A required name of the editor class. The name should reflect the constructor name.
+     */
+    static get editorName(): `${string}Editor`;
     /**
      * A namespace for the accessibility features of the editor.
      */
@@ -447,6 +451,14 @@ export default abstract class Editor extends /* #__PURE__ */ Editor_base {
      * Exposed as static editor field for easier access in editor builds.
      */
     static ContextWatchdog: typeof ContextWatchdog;
+    private _showLicenseError;
+    /**
+     * This part of the code is _not_ executed in installations under the GPL license (with `config.licenseKey = 'GPL'`).
+     *
+     * It is only executed when a specific license key is provided. If you are uncertain whether
+     * this applies to your installation, please contact our support team.
+     */
+    private _sendUsageRequest;
 }
 /**
  * Fired when the {@link module:engine/controller/datacontroller~DataController#event:ready data} and all additional
@@ -466,6 +478,23 @@ export type EditorReadyEvent = {
     name: 'ready';
     args: [];
 };
+/**
+ * Fired when the editor is about to collect usage data.
+ *
+ * This event is fired when the editor is about to collect usage data. It allows plugins to provide additional data for
+ * the usage statistics. The usage data is collected by the editor and sent to the usage tracking server. All plugins are
+ * expected to be ready at this point.
+ *
+ * @eventName ~Editor#collectUsageData
+ */
+export type EditorCollectUsageDataEvent = {
+    name: 'collectUsageData';
+    args: [
+        {
+            setUsageData(path: string, value: unknown): void;
+        }
+    ];
+};
 /**
  * Fired when this editor instance is destroyed. The editor at this point is not usable and this event should be used to
  * perform the clean-up in any plugin.

package/src/editor/editor.js

@@ -5,7 +5,8 @@
 /**
  * @module core/editor/editor
  */
-import { Config, CKEditorError, ObservableMixin } from '@ckeditor/ckeditor5-utils';
+import { set, get } from 'lodash-es';
+import { Config, CKEditorError, ObservableMixin, logError, parseBase64EncodedObject, releaseDate, toArray, uid, crc32 } from '@ckeditor/ckeditor5-utils';
 import { Conversion, DataController, EditingController, Model, StylesProcessor } from '@ckeditor/ckeditor5-engine';
 import { ContextWatchdog, EditorWatchdog } from '@ckeditor/ckeditor5-watchdog';
 import Context from '../context.js';
@@ -13,6 +14,7 @@ import PluginCollection from '../plugincollection.js';
 import CommandCollection from '../commandcollection.js';
 import EditingKeystrokeHandler from '../editingkeystrokehandler.js';
 import Accessibility from '../accessibility.js';
+import { getEditorUsageData } from './utils/editorusagedata.js';
 /**
  * The class representing a basic, generic editor.
  *
@@ -32,6 +34,12 @@ import Accessibility from '../accessibility.js';
  * (as most editor implementations do).
  */
 class Editor extends /* #__PURE__ */ ObservableMixin() {
+    /**
+     * A required name of the editor class. The name should reflect the constructor name.
+     */
+    static get editorName() {
+        return 'Editor';
+    }
     /**
      * Creates a new instance of the editor class.
      *
@@ -66,6 +74,7 @@ class Editor extends /* #__PURE__ */ ObservableMixin() {
         this.config = new Config(rest, defaultConfig);
         this.config.define('plugins', availablePlugins);
         this.config.define(this._context._getEditorConfig());
+        checkLicenseKeyIsDefined(this.config);
         this.plugins = new PluginCollection(this, availablePlugins, this._context.plugins);
         this.locale = this._context.locale;
         this.t = this.locale.t;
@@ -88,6 +97,165 @@ class Editor extends /* #__PURE__ */ ObservableMixin() {
         this.keystrokes = new EditingKeystrokeHandler(this);
         this.keystrokes.listenTo(this.editing.view.document);
         this.accessibility = new Accessibility(this);
+        verifyLicenseKey(this);
+        // Checks if the license key is defined and throws an error if it is not.
+        function checkLicenseKeyIsDefined(config) {
+            let licenseKey = config.get('licenseKey');
+            if (!licenseKey && window.CKEDITOR_GLOBAL_LICENSE_KEY) {
+                licenseKey = window.CKEDITOR_GLOBAL_LICENSE_KEY;
+                config.set('licenseKey', licenseKey);
+            }
+            if (!licenseKey) {
+                /**
+                 * The `licenseKey` property is missing in the editor configuration.
+                 *
+                 * * If you are using the editor in a commercial setup, please provide your license key.
+                 * * If you still need to acquire a key, please [contact us](https://ckeditor.com/contact/) or
+                 *   [create a free account with a 14 day premium features trial](https://portal.ckeditor.com/checkout?plan=free).
+                 * * If you are using the editor under a GPL license or another license from our Open Source Initiative,
+                 *   use the 'GPL' license key instead.
+                 *
+                 * ```js
+                 * ClassicEditor.create( document.querySelector( '#editor' ), {
+                 * 	licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
+                 * 	// ... Other configuration options ...
+                 * } ) ;
+                 *
+                 * @error license-key-missing
+                 */
+                throw new CKEditorError('license-key-missing');
+            }
+        }
+        function verifyLicenseKey(editor) {
+            const licenseKey = editor.config.get('licenseKey');
+            const distributionChannel = window[Symbol.for('cke distribution')] || 'sh';
+            function blockEditor(reason) {
+                editor.enableReadOnlyMode(Symbol('invalidLicense'));
+                editor._showLicenseError(reason);
+            }
+            function getPayload(licenseKey) {
+                const parts = licenseKey.split('.');
+                if (parts.length != 3) {
+                    return null;
+                }
+                return parts[1];
+            }
+            function hasAllRequiredFields(licensePayload) {
+                const requiredFields = ['exp', 'jti', 'vc'];
+                return requiredFields.every(field => field in licensePayload);
+            }
+            function getCrcInputData(licensePayload) {
+                const keysToCheck = Object.getOwnPropertyNames(licensePayload).sort();
+                const filteredValues = keysToCheck
+                    .filter(key => key != 'vc' && licensePayload[key] != null)
+                    .map(key => licensePayload[key]);
+                return filteredValues;
+            }
+            function checkLicensedHosts(licensedHosts) {
+                const { hostname } = new URL(window.location.href);
+                if (licensedHosts.includes(hostname)) {
+                    return true;
+                }
+                const segments = hostname.split('.');
+                return licensedHosts
+                    // Filter out hosts without wildcards.
+                    .filter(host => host.includes('*'))
+                    // Split the hosts into segments.
+                    .map(host => host.split('.'))
+                    // Filter out hosts that have more segments than the current hostname.
+                    .filter(host => host.length <= segments.length)
+                    // Pad the beginning of the licensed host if it's shorter than the current hostname.
+                    .map(host => Array(segments.length - host.length).fill(host[0] === '*' ? '*' : '').concat(host))
+                    // Check if some license host matches the hostname.
+                    .some(octets => segments.every((segment, index) => octets[index] === segment || octets[index] === '*'));
+            }
+            if (licenseKey == 'GPL') {
+                if (distributionChannel == 'cloud') {
+                    blockEditor('distributionChannel');
+                }
+                return;
+            }
+            const encodedPayload = getPayload(licenseKey);
+            if (!encodedPayload) {
+                blockEditor('invalid');
+                return;
+            }
+            const licensePayload = parseBase64EncodedObject(encodedPayload);
+            if (!licensePayload) {
+                blockEditor('invalid');
+                return;
+            }
+            if (!hasAllRequiredFields(licensePayload)) {
+                blockEditor('invalid');
+                return;
+            }
+            if (licensePayload.distributionChannel && !toArray(licensePayload.distributionChannel).includes(distributionChannel)) {
+                blockEditor('distributionChannel');
+                return;
+            }
+            if (crc32(getCrcInputData(licensePayload)) != licensePayload.vc.toLowerCase()) {
+                blockEditor('invalid');
+                return;
+            }
+            const expirationDate = new Date(licensePayload.exp * 1000);
+            if (expirationDate < releaseDate) {
+                blockEditor('expired');
+                return;
+            }
+            const licensedHosts = licensePayload.licensedHosts;
+            if (licensedHosts && licensedHosts.length > 0 && !checkLicensedHosts(licensedHosts)) {
+                blockEditor('domainLimit');
+                return;
+            }
+            if (['evaluation', 'trial'].includes(licensePayload.licenseType) && licensePayload.exp * 1000 < Date.now()) {
+                blockEditor('expired');
+                return;
+            }
+            if (['evaluation', 'trial', 'development'].includes(licensePayload.licenseType)) {
+                const licenseType = licensePayload.licenseType;
+                console.info(`You are using the ${licenseType} version of CKEditor 5 with limited usage. ` +
+                    'Make sure you will not use it in the production environment.');
+                const timerId = setTimeout(() => {
+                    blockEditor(`${licenseType}Limit`);
+                }, 600000);
+                editor.on('destroy', () => {
+                    clearTimeout(timerId);
+                });
+            }
+            if (licensePayload.usageEndpoint) {
+                editor.once('ready', () => {
+                    const request = {
+                        requestId: uid(),
+                        requestTime: Math.round(Date.now() / 1000),
+                        license: licenseKey,
+                        editor: collectUsageData(editor)
+                    };
+                    /**
+                     * This part of the code is not executed in open-source implementations using a GPL key.
+                     * It only runs when a specific license key is provided. If you are uncertain whether
+                     * this applies to your installation, please contact our support team.
+                     */
+                    editor._sendUsageRequest(licensePayload.usageEndpoint, request).then(response => {
+                        const { status, message } = response;
+                        if (message) {
+                            console.warn(message);
+                        }
+                        if (status != 'ok') {
+                            blockEditor('usageLimit');
+                        }
+                    }, () => {
+                        /**
+                         * Your license key cannot be validated due to a network issue.
+                         * Please ensure that your setup does not block requests to the validation endpoint.
+                         *
+                         * @error license-key-validation-endpoint-not-reachable
+                         * @param {String} url The URL that was attempted to be reached for validation.
+                         */
+                        logError('license-key-validation-endpoint-not-reachable', { url: licensePayload.usageEndpoint });
+                    });
+                }, { priority: 'high' });
+            }
+        }
     }
     /**
      * Defines whether the editor is in the read-only mode.
@@ -370,6 +538,136 @@ class Editor extends /* #__PURE__ */ ObservableMixin() {
     static create(...args) {
         throw new Error('This is an abstract method.');
     }
+    _showLicenseError(reason, pluginName) {
+        setTimeout(() => {
+            if (reason == 'invalid') {
+                /**
+                 * The license key provided is invalid. Please ensure that it is copied correctly
+                 * from the [Customer Portal](http://portal.ckeditor.com). If the issue persists,
+                 * please [contact our customer support](https://ckeditor.com/contact/).
+                 *
+                 * @error invalid-license-key
+                 */
+                throw new CKEditorError('invalid-license-key');
+            }
+            if (reason == 'expired') {
+                /**
+                 * Your license key has expired. Please renew your license on the
+                 * [Customer Portal](https://portal.ckeditor.com).
+                 *
+                 * @error license-key-expired
+                 */
+                throw new CKEditorError('license-key-expired');
+            }
+            if (reason == 'domainLimit') {
+                /**
+                 * The provided license does not allow the editor to run on this domain.
+                 * Some license keys are restricted to local test environments only.
+                 * For more details, please refer to the
+                 * {@glink getting-started/licensing/license-key-and-activation#license-key-types license key type documentation}.
+                 *
+                 * @error license-key-domain-limit
+                 */
+                throw new CKEditorError('license-key-domain-limit');
+            }
+            if (reason == 'featureNotAllowed') {
+                /**
+                 * The plugin you are trying to use is not permitted under your current license.
+                 * Please check the available features on the
+                 * [Customer Portal](https://portal.ckeditor.com) or
+                 * [contact support](https://ckeditor.com/contact/) for more information.
+                 *
+                 * @error license-key-plugin-not-allowed
+                 * @param {String} pluginName The plugin you tried to load.
+                 */
+                throw new CKEditorError('license-key-plugin-not-allowed', null, { pluginName });
+            }
+            if (reason == 'evaluationLimit') {
+                /**
+                 * You have exceeded the editor operation limit available for your evaluation license key.
+                 * Please restart the editor to continue using it.
+                 * {@glink getting-started/licensing/license-key-and-activation#license-key-types Read more about license key types}.
+                 *
+                 * @error license-key-evaluation-limit
+                 */
+                throw new CKEditorError('license-key-evaluation-limit');
+            }
+            if (reason == 'trialLimit') {
+                /**
+                 * You have exceeded the editor operation limit for your trial license key.
+                 * Please restart the editor to continue using it.
+                 * {@glink getting-started/licensing/license-key-and-activation#license-key-types Read more about license key types}.
+                 *
+                 * @error license-key-trial-limit
+                 */
+                throw new CKEditorError('license-key-trial-limit');
+            }
+            if (reason == 'developmentLimit') {
+                /**
+                 * You have exceeded the operation limit for your development license key within the editor.
+                 * Please restart the editor to continue using it.
+                 * {@glink getting-started/licensing/license-key-and-activation#license-key-types Read more about license key types}.
+                 *
+                 * @error license-key-development-limit
+                 */
+                throw new CKEditorError('license-key-development-limit');
+            }
+            if (reason == 'usageLimit') {
+                /**
+                 * You have reached the usage limit of your license key. This can occur in the following situations:
+                 *
+                 * * You are on a free subscription without a connected payment method and have exceeded the allowed usage threshold.
+                 * * Your account has overdue invoices and the grace period has ended.
+                 *
+                 * To extend the limit and restore access, please update the required details in the
+                 * [Customer Portal](https://portal.ckeditor.com) or
+                 * [contact our customer support](https://ckeditor.com/contact).
+                 *
+                 * @error license-key-usage-limit
+                 */
+                throw new CKEditorError('license-key-usage-limit');
+            }
+            if (reason == 'distributionChannel') {
+                /**
+                 * Your license does not allow the current distribution channel.
+                 *
+                 * * With a 'GPL' license key, you may use the editor installed via npm or a ZIP package (self-hosted).
+                 * * With the CKEditor Cloud plans, you may use the editor via our CDN.
+                 * * With the CKEditor Custom plans, depending on your plan details, you can use the editor via npm
+                 *   or a ZIP package (self-hosted) or Cloud (CDN)
+                 *
+                 * {@glink getting-started/licensing/usage-based-billing#key-terms Read more about distributions in the documentation}.
+                 * Please verify your installation or [contact support](https://ckeditor.com/contact/) for assistance.
+                 *
+                 * @error license-key-invalid-distribution-channel
+                 */
+                throw new CKEditorError('license-key-invalid-distribution-channel');
+            }
+            /* istanbul ignore next -- @preserve */
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            const unreachable = reason;
+        }, 0);
+        this._showLicenseError = () => { };
+    }
+    /**
+     * This part of the code is _not_ executed in installations under the GPL license (with `config.licenseKey = 'GPL'`).
+     *
+     * It is only executed when a specific license key is provided. If you are uncertain whether
+     * this applies to your installation, please contact our support team.
+     */
+    async _sendUsageRequest(endpoint, request) {
+        const headers = new Headers({ 'Content-Type': 'application/json' });
+        const response = await fetch(new URL(endpoint), {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(request)
+        });
+        if (!response.ok) {
+            // TODO: refine message.
+            throw new Error(`HTTP Response: ${response.status}`);
+        }
+        return response.json();
+    }
 }
 /**
  * The {@link module:core/context~Context} class.
@@ -390,6 +688,25 @@ Editor.EditorWatchdog = EditorWatchdog;
  */
 Editor.ContextWatchdog = ContextWatchdog;
 export default Editor;
+function collectUsageData(editor) {
+    const collectedData = getEditorUsageData(editor);
+    function setUsageData(path, value) {
+        if (get(collectedData, path) !== undefined) {
+            /**
+             * The error thrown when trying to set the usage data path that was already set.
+             * Make sure that you are not setting the same path multiple times.
+             *
+             * @error editor-usage-data-path-already-set
+             */
+            throw new CKEditorError('editor-usage-data-path-already-set', { path });
+        }
+        set(collectedData, path, value);
+    }
+    editor.fire('collectUsageData', {
+        setUsageData
+    });
+    return collectedData;
+}
 /**
  * This error is thrown when trying to pass a `<textarea>` element to a `create()` function of an editor class.
  *

package/src/editor/editorconfig.d.ts

@@ -795,10 +795,12 @@ export interface EditorConfig {
      */
     updateSourceElementOnDestroy?: boolean;
     /**
-     * The license key for the CKEditor 5 commercial license and the premium features.
+     * The CKEditor 5 license key. If you want to obtain a license key, please do one of the following:
      *
-     * If you do not have a key yet, please [contact us](https://ckeditor.com/contact/) or
-     * [order a trial](https://orders.ckeditor.com/trial/premium-features).
+     * * Create a free account, and test the premium features with a [14-day free trial](https://portal.ckeditor.com/checkout?plan=free).
+     * * [Contact us](https://ckeditor.com/contact/) for a commercial license.
+     * * If you are using the editor under a GPL license or another license from our Open Source Initiative,
+     *   use the 'GPL' license key instead.
      */
     licenseKey?: string;
     /**
@@ -910,7 +912,7 @@ export interface PoweredByConfig {
      *
      * @default 'border'
      */
-    position: 'inside' | 'border';
+    position?: 'inside' | 'border';
     /**
      * Allows choosing the side of the editing area where the logo will be displayed.
      *
@@ -919,7 +921,7 @@ export interface PoweredByConfig {
      *
      * @default 'right'
      */
-    side: 'left' | 'right';
+    side?: 'left' | 'right';
     /**
      * Allows changing the label displayed next to the CKEditor logo.
      *
@@ -927,7 +929,7 @@ export interface PoweredByConfig {
      *
      * @default 'Powered by'
      */
-    label: string | null;
+    label?: string | null;
     /**
      * The vertical distance the logo can be moved away from its default position.
      *
@@ -935,13 +937,13 @@ export interface PoweredByConfig {
      *
      * @default 5
      */
-    verticalOffset: number;
+    verticalOffset?: number;
     /**
      * The horizontal distance between the side of the editing root and the nearest side of the logo.
      *
      * @default 5
      */
-    horizontalOffset: number;
+    horizontalOffset?: number;
     /**
      * Allows to show the logo even if the valid commercial license is configured using
      * the {@link module:core/editor/editorconfig~EditorConfig#licenseKey `config.licenseKey`} setting.

package/src/editor/utils/editorusagedata.d.ts

@@ -0,0 +1,68 @@
+/**
+ * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+import type Editor from '../editor.js';
+/**
+ * This part of the code is not executed in open-source implementations using a GPL key.
+ * It only runs when a specific license key is provided. If you are uncertain whether
+ * this applies to your installation, please contact our support team.
+ *
+ * @internal
+ */
+export declare function getEditorUsageData(editor: Editor): EditorUsageData;
+declare global {
+    interface Window {
+        CKEDITOR_PAGE_SESSION_ID?: string;
+    }
+}
+/**
+ * @internal
+ */
+export type EditorUsageData = {
+    sessionId: string;
+    pageSessionId: string;
+    hostname: string;
+    version: string;
+    type: `${string}Editor`;
+    plugins: Array<PluginUsageData>;
+    toolbar: {
+        main?: ToolbarUsageData;
+        block?: ToolbarUsageData;
+        balloon?: ToolbarUsageData;
+    };
+    menuBar: {
+        isVisible: boolean;
+    };
+    language: {
+        ui: string;
+        content: string;
+    };
+    distribution: {
+        channel: string;
+    };
+    env: EnvUsageData;
+    integration: {
+        [integrationName: string]: IntegrationUsageData;
+    };
+};
+type IntegrationUsageData = {
+    version: string;
+    frameworkVersion?: string;
+};
+type EnvUsageData = {
+    os: 'mac' | 'windows' | 'ios' | 'android' | 'unknown';
+    browser: 'safari' | 'gecko' | 'blink' | 'unknown';
+};
+type ToolbarUsageData = {
+    items: Array<string>;
+    isMultiline: boolean;
+    shouldNotGroupWhenFull: boolean;
+};
+type PluginUsageData = {
+    name: string;
+    isPremium: boolean;
+    isOfficial: boolean;
+    isContext: boolean;
+};
+export {};