@ckeditor/ckeditor5-image 40.0.0 → 40.1.0

package/src/image/imageplaceholder.js

@@ -0,0 +1,113 @@
+/**
+ * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @module image/image/imageplaceholder
+ */
+import { Plugin } from 'ckeditor5/src/core';
+import ImageUtils from '../imageutils';
+import ImageLoadObserver from './imageloadobserver';
+import '../../theme/imageplaceholder.css';
+/**
+ * Adds support for image placeholder that is automatically removed when the image is loaded.
+ */
+export default class ImagePlaceholder extends Plugin {
+    /**
+     * @inheritDoc
+     */
+    static get requires() {
+        return [ImageUtils];
+    }
+    /**
+     * @inheritDoc
+     */
+    static get pluginName() {
+        return 'ImagePlaceholder';
+    }
+    /**
+     * @inheritDoc
+     */
+    afterInit() {
+        this._setupSchema();
+        this._setupConversion();
+        this._setupLoadListener();
+    }
+    /**
+     * Extends model schema.
+     */
+    _setupSchema() {
+        const schema = this.editor.model.schema;
+        // Wait for ImageBlockEditing or ImageInlineEditing to register their elements first,
+        // that's why doing this in afterInit() instead of init().
+        if (schema.isRegistered('imageBlock')) {
+            schema.extend('imageBlock', {
+                allowAttributes: ['placeholder']
+            });
+        }
+        if (schema.isRegistered('imageInline')) {
+            schema.extend('imageInline', {
+                allowAttributes: ['placeholder']
+            });
+        }
+    }
+    /**
+     * Registers converters.
+     */
+    _setupConversion() {
+        const editor = this.editor;
+        const conversion = editor.conversion;
+        const imageUtils = editor.plugins.get('ImageUtils');
+        conversion.for('editingDowncast').add(dispatcher => {
+            dispatcher.on('attribute:placeholder', (evt, data, conversionApi) => {
+                if (!conversionApi.consumable.test(data.item, evt.name)) {
+                    return;
+                }
+                if (!data.item.is('element', 'imageBlock') && !data.item.is('element', 'imageInline')) {
+                    return;
+                }
+                conversionApi.consumable.consume(data.item, evt.name);
+                const viewWriter = conversionApi.writer;
+                const element = conversionApi.mapper.toViewElement(data.item);
+                const img = imageUtils.findViewImgElement(element);
+                if (data.attributeNewValue) {
+                    viewWriter.addClass('image_placeholder', img);
+                    viewWriter.setStyle('background-image', `url(${data.attributeNewValue})`, img);
+                    viewWriter.setCustomProperty('editingPipeline:doNotReuseOnce', true, img);
+                }
+                else {
+                    viewWriter.removeClass('image_placeholder', img);
+                    viewWriter.removeStyle('background-image', img);
+                }
+            });
+        });
+    }
+    /**
+     * Prepares listener for image load.
+     */
+    _setupLoadListener() {
+        const editor = this.editor;
+        const model = editor.model;
+        const editing = editor.editing;
+        const editingView = editing.view;
+        const imageUtils = editor.plugins.get('ImageUtils');
+        editingView.addObserver(ImageLoadObserver);
+        this.listenTo(editingView.document, 'imageLoaded', (evt, domEvent) => {
+            const imgViewElement = editingView.domConverter.mapDomToView(domEvent.target);
+            if (!imgViewElement) {
+                return;
+            }
+            const viewElement = imageUtils.getImageWidgetFromImageView(imgViewElement);
+            if (!viewElement) {
+                return;
+            }
+            const modelElement = editing.mapper.toModelElement(viewElement);
+            if (!modelElement || !modelElement.hasAttribute('placeholder')) {
+                return;
+            }
+            model.enqueueChange({ isUndoable: false }, writer => {
+                writer.removeAttribute('placeholder', modelElement);
+            });
+        });
+    }
+}

package/src/image/imagetypecommand.d.ts

@@ -1,44 +1,44 @@
-/**
- * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
- */
-/**
- * @module image/image/imagetypecommand
- */
-import type { Element } from 'ckeditor5/src/engine';
-import { Command, type Editor } from 'ckeditor5/src/core';
-/**
- * The image type command. It changes the type of a selected image, depending on the configuration.
- */
-export default class ImageTypeCommand extends Command {
-    /**
-     * Model element name the command converts to.
-     */
-    private readonly _modelElementName;
-    /**
-     * @inheritDoc
-     *
-     * @param modelElementName Model element name the command converts to.
-     */
-    constructor(editor: Editor, modelElementName: 'imageBlock' | 'imageInline');
-    /**
-     * @inheritDoc
-     */
-    refresh(): void;
-    /**
-     * Executes the command and changes the type of a selected image.
-     *
-     * @fires execute
-     * @param options.setImageSizes Specifies whether the image `width` and `height` attributes should be set automatically.
-     * The default is `true`.
-     * @returns An object containing references to old and new model image elements
-     * (for before and after the change) so external integrations can hook into the decorated
-     * `execute` event and handle this change. `null` if the type change failed.
-     */
-    execute(options?: {
-        setImageSizes?: boolean;
-    }): {
-        oldElement: Element;
-        newElement: Element;
-    } | null;
-}
+/**
+ * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @module image/image/imagetypecommand
+ */
+import type { Element } from 'ckeditor5/src/engine';
+import { Command, type Editor } from 'ckeditor5/src/core';
+/**
+ * The image type command. It changes the type of a selected image, depending on the configuration.
+ */
+export default class ImageTypeCommand extends Command {
+    /**
+     * Model element name the command converts to.
+     */
+    private readonly _modelElementName;
+    /**
+     * @inheritDoc
+     *
+     * @param modelElementName Model element name the command converts to.
+     */
+    constructor(editor: Editor, modelElementName: 'imageBlock' | 'imageInline');
+    /**
+     * @inheritDoc
+     */
+    refresh(): void;
+    /**
+     * Executes the command and changes the type of a selected image.
+     *
+     * @fires execute
+     * @param options.setImageSizes Specifies whether the image `width` and `height` attributes should be set automatically.
+     * The default is `true`.
+     * @returns An object containing references to old and new model image elements
+     * (for before and after the change) so external integrations can hook into the decorated
+     * `execute` event and handle this change. `null` if the type change failed.
+     */
+    execute(options?: {
+        setImageSizes?: boolean;
+    }): {
+        oldElement: Element;
+        newElement: Element;
+    } | null;
+}

package/src/image/imagetypecommand.js

@@ -1,80 +1,80 @@
-/**
- * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
- */
-import { Command } from 'ckeditor5/src/core';
-/**
- * The image type command. It changes the type of a selected image, depending on the configuration.
- */
-export default class ImageTypeCommand extends Command {
-    /**
-     * @inheritDoc
-     *
-     * @param modelElementName Model element name the command converts to.
-     */
-    constructor(editor, modelElementName) {
-        super(editor);
-        this._modelElementName = modelElementName;
-    }
-    /**
-     * @inheritDoc
-     */
-    refresh() {
-        const editor = this.editor;
-        const imageUtils = editor.plugins.get('ImageUtils');
-        const element = imageUtils.getClosestSelectedImageElement(this.editor.model.document.selection);
-        if (this._modelElementName === 'imageBlock') {
-            this.isEnabled = imageUtils.isInlineImage(element);
-        }
-        else {
-            this.isEnabled = imageUtils.isBlockImage(element);
-        }
-    }
-    /**
-     * Executes the command and changes the type of a selected image.
-     *
-     * @fires execute
-     * @param options.setImageSizes Specifies whether the image `width` and `height` attributes should be set automatically.
-     * The default is `true`.
-     * @returns An object containing references to old and new model image elements
-     * (for before and after the change) so external integrations can hook into the decorated
-     * `execute` event and handle this change. `null` if the type change failed.
-     */
-    execute(options = {}) {
-        const editor = this.editor;
-        const model = this.editor.model;
-        const imageUtils = editor.plugins.get('ImageUtils');
-        const oldElement = imageUtils.getClosestSelectedImageElement(model.document.selection);
-        const attributes = Object.fromEntries(oldElement.getAttributes());
-        // Don't change image type if "src" is missing (a broken image), unless there's "uploadId" set.
-        // This state may happen during image upload (before it finishes) and it should be possible to change type
-        // of the image in the meantime.
-        if (!attributes.src && !attributes.uploadId) {
-            return null;
-        }
-        return model.change(writer => {
-            const { setImageSizes = true } = options;
-            // Get all markers that contain the old image element.
-            const markers = Array.from(model.markers)
-                .filter(marker => marker.getRange().containsItem(oldElement));
-            const newElement = imageUtils.insertImage(attributes, model.createSelection(oldElement, 'on'), this._modelElementName, { setImageSizes });
-            if (!newElement) {
-                return null;
-            }
-            const newElementRange = writer.createRangeOn(newElement);
-            // Expand the previously intersecting markers' ranges to include the new image element.
-            for (const marker of markers) {
-                const markerRange = marker.getRange();
-                // Join the survived part of the old marker range with the new element range
-                // (loosely because there could be some new paragraph or the existing one might got split).
-                const range = markerRange.root.rootName != '$graveyard' ?
-                    markerRange.getJoined(newElementRange, true) : newElementRange;
-                writer.updateMarker(marker, { range });
-            }
-            return {
-                oldElement,
-                newElement
-            };
-        });
-    }
-}
+/**
+ * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+import { Command } from 'ckeditor5/src/core';
+/**
+ * The image type command. It changes the type of a selected image, depending on the configuration.
+ */
+export default class ImageTypeCommand extends Command {
+    /**
+     * @inheritDoc
+     *
+     * @param modelElementName Model element name the command converts to.
+     */
+    constructor(editor, modelElementName) {
+        super(editor);
+        this._modelElementName = modelElementName;
+    }
+    /**
+     * @inheritDoc
+     */
+    refresh() {
+        const editor = this.editor;
+        const imageUtils = editor.plugins.get('ImageUtils');
+        const element = imageUtils.getClosestSelectedImageElement(this.editor.model.document.selection);
+        if (this._modelElementName === 'imageBlock') {
+            this.isEnabled = imageUtils.isInlineImage(element);
+        }
+        else {
+            this.isEnabled = imageUtils.isBlockImage(element);
+        }
+    }
+    /**
+     * Executes the command and changes the type of a selected image.
+     *
+     * @fires execute
+     * @param options.setImageSizes Specifies whether the image `width` and `height` attributes should be set automatically.
+     * The default is `true`.
+     * @returns An object containing references to old and new model image elements
+     * (for before and after the change) so external integrations can hook into the decorated
+     * `execute` event and handle this change. `null` if the type change failed.
+     */
+    execute(options = {}) {
+        const editor = this.editor;
+        const model = this.editor.model;
+        const imageUtils = editor.plugins.get('ImageUtils');
+        const oldElement = imageUtils.getClosestSelectedImageElement(model.document.selection);
+        const attributes = Object.fromEntries(oldElement.getAttributes());
+        // Don't change image type if "src" is missing (a broken image), unless there's "uploadId" set.
+        // This state may happen during image upload (before it finishes) and it should be possible to change type
+        // of the image in the meantime.
+        if (!attributes.src && !attributes.uploadId) {
+            return null;
+        }
+        return model.change(writer => {
+            const { setImageSizes = true } = options;
+            // Get all markers that contain the old image element.
+            const markers = Array.from(model.markers)
+                .filter(marker => marker.getRange().containsItem(oldElement));
+            const newElement = imageUtils.insertImage(attributes, model.createSelection(oldElement, 'on'), this._modelElementName, { setImageSizes });
+            if (!newElement) {
+                return null;
+            }
+            const newElementRange = writer.createRangeOn(newElement);
+            // Expand the previously intersecting markers' ranges to include the new image element.
+            for (const marker of markers) {
+                const markerRange = marker.getRange();
+                // Join the survived part of the old marker range with the new element range
+                // (loosely because there could be some new paragraph or the existing one might got split).
+                const range = markerRange.root.rootName != '$graveyard' ?
+                    markerRange.getJoined(newElementRange, true) : newElementRange;
+                writer.updateMarker(marker, { range });
+            }
+            return {
+                oldElement,
+                newElement
+            };
+        });
+    }
+}

package/src/image/insertimagecommand.d.ts

@@ -1,66 +1,66 @@
-/**
- * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
- */
-/**
- * @module image/image/insertimagecommand
- */
-import { Command, type Editor } from 'ckeditor5/src/core';
-import { type ArrayOrItem } from 'ckeditor5/src/utils';
-/**
- * Insert image command.
- *
- * The command is registered by the {@link module:image/image/imageediting~ImageEditing} plugin as `insertImage`
- * and it is also available via aliased `imageInsert` name.
- *
- * In order to insert an image at the current selection position
- * (according to the {@link module:widget/utils~findOptimalInsertionRange} algorithm),
- * execute the command and specify the image source:
- *
- * ```ts
- * editor.execute( 'insertImage', { source: 'http://url.to.the/image' } );
- * ```
- *
- * It is also possible to insert multiple images at once:
- *
- * ```ts
- * editor.execute( 'insertImage', {
- * 	source:  [
- * 		'path/to/image.jpg',
- * 		'path/to/other-image.jpg'
- * 	]
- * } );
- * ```
- *
- * If you want to take the full control over the process, you can specify individual model attributes:
- *
- * ```ts
- * editor.execute( 'insertImage', {
- * 	source:  [
- * 		{ src: 'path/to/image.jpg', alt: 'First alt text' },
- * 		{ src: 'path/to/other-image.jpg', alt: 'Second alt text', customAttribute: 'My attribute value' }
- * 	]
- * } );
- * ```
- */
-export default class InsertImageCommand extends Command {
-    /**
-     * @inheritDoc
-     */
-    constructor(editor: Editor);
-    /**
-     * @inheritDoc
-     */
-    refresh(): void;
-    /**
-     * Executes the command.
-     *
-     * @fires execute
-     * @param options Options for the executed command.
-     * @param options.source The image source or an array of image sources to insert.
-     * See the documentation of the command to learn more about accepted formats.
-     */
-    execute(options: {
-        source: ArrayOrItem<string | Record<string, unknown>>;
-    }): void;
-}
+/**
+ * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @module image/image/insertimagecommand
+ */
+import { Command, type Editor } from 'ckeditor5/src/core';
+import { type ArrayOrItem } from 'ckeditor5/src/utils';
+/**
+ * Insert image command.
+ *
+ * The command is registered by the {@link module:image/image/imageediting~ImageEditing} plugin as `insertImage`
+ * and it is also available via aliased `imageInsert` name.
+ *
+ * In order to insert an image at the current selection position
+ * (according to the {@link module:widget/utils~findOptimalInsertionRange} algorithm),
+ * execute the command and specify the image source:
+ *
+ * ```ts
+ * editor.execute( 'insertImage', { source: 'http://url.to.the/image' } );
+ * ```
+ *
+ * It is also possible to insert multiple images at once:
+ *
+ * ```ts
+ * editor.execute( 'insertImage', {
+ * 	source:  [
+ * 		'path/to/image.jpg',
+ * 		'path/to/other-image.jpg'
+ * 	]
+ * } );
+ * ```
+ *
+ * If you want to take the full control over the process, you can specify individual model attributes:
+ *
+ * ```ts
+ * editor.execute( 'insertImage', {
+ * 	source:  [
+ * 		{ src: 'path/to/image.jpg', alt: 'First alt text' },
+ * 		{ src: 'path/to/other-image.jpg', alt: 'Second alt text', customAttribute: 'My attribute value' }
+ * 	]
+ * } );
+ * ```
+ */
+export default class InsertImageCommand extends Command {
+    /**
+     * @inheritDoc
+     */
+    constructor(editor: Editor);
+    /**
+     * @inheritDoc
+     */
+    refresh(): void;
+    /**
+     * Executes the command.
+     *
+     * @fires execute
+     * @param options Options for the executed command.
+     * @param options.source The image source or an array of image sources to insert.
+     * See the documentation of the command to learn more about accepted formats.
+     */
+    execute(options: {
+        source: ArrayOrItem<string | Record<string, unknown>>;
+    }): void;
+}