@ckeditor/ckeditor5-enter 40.0.0 → 40.1.0

package/src/enterobserver.js

@@ -1,61 +1,61 @@
-/**
- * @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 enter/enterobserver
- */
-import { Observer, DomEventData, BubblingEventInfo } from '@ckeditor/ckeditor5-engine';
-import { env } from '@ckeditor/ckeditor5-utils';
-const ENTER_EVENT_TYPES = {
-    insertParagraph: { isSoft: false },
-    insertLineBreak: { isSoft: true }
-};
-/**
- * Enter observer introduces the {@link module:engine/view/document~Document#event:enter `Document#enter`} event.
- */
-export default class EnterObserver extends Observer {
-    /**
-     * @inheritDoc
-     */
-    constructor(view) {
-        super(view);
-        const doc = this.document;
-        let shiftPressed = false;
-        doc.on('keydown', (evt, data) => {
-            shiftPressed = data.shiftKey;
-        });
-        doc.on('beforeinput', (evt, data) => {
-            if (!this.isEnabled) {
-                return;
-            }
-            let inputType = data.inputType;
-            // See https://github.com/ckeditor/ckeditor5/issues/13321.
-            if (env.isSafari && shiftPressed && inputType == 'insertParagraph') {
-                inputType = 'insertLineBreak';
-            }
-            const domEvent = data.domEvent;
-            const enterEventSpec = ENTER_EVENT_TYPES[inputType];
-            if (!enterEventSpec) {
-                return;
-            }
-            const event = new BubblingEventInfo(doc, 'enter', data.targetRanges[0]);
-            doc.fire(event, new DomEventData(view, domEvent, {
-                isSoft: enterEventSpec.isSoft
-            }));
-            // Stop `beforeinput` event if `enter` event was stopped.
-            // https://github.com/ckeditor/ckeditor5/issues/753
-            if (event.stop.called) {
-                evt.stop();
-            }
-        });
-    }
-    /**
-     * @inheritDoc
-     */
-    observe() { }
-    /**
-     * @inheritDoc
-     */
-    stopObserving() { }
-}
+/**
+ * @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 enter/enterobserver
+ */
+import { Observer, DomEventData, BubblingEventInfo } from '@ckeditor/ckeditor5-engine';
+import { env } from '@ckeditor/ckeditor5-utils';
+const ENTER_EVENT_TYPES = {
+    insertParagraph: { isSoft: false },
+    insertLineBreak: { isSoft: true }
+};
+/**
+ * Enter observer introduces the {@link module:engine/view/document~Document#event:enter `Document#enter`} event.
+ */
+export default class EnterObserver extends Observer {
+    /**
+     * @inheritDoc
+     */
+    constructor(view) {
+        super(view);
+        const doc = this.document;
+        let shiftPressed = false;
+        doc.on('keydown', (evt, data) => {
+            shiftPressed = data.shiftKey;
+        });
+        doc.on('beforeinput', (evt, data) => {
+            if (!this.isEnabled) {
+                return;
+            }
+            let inputType = data.inputType;
+            // See https://github.com/ckeditor/ckeditor5/issues/13321.
+            if (env.isSafari && shiftPressed && inputType == 'insertParagraph') {
+                inputType = 'insertLineBreak';
+            }
+            const domEvent = data.domEvent;
+            const enterEventSpec = ENTER_EVENT_TYPES[inputType];
+            if (!enterEventSpec) {
+                return;
+            }
+            const event = new BubblingEventInfo(doc, 'enter', data.targetRanges[0]);
+            doc.fire(event, new DomEventData(view, domEvent, {
+                isSoft: enterEventSpec.isSoft
+            }));
+            // Stop `beforeinput` event if `enter` event was stopped.
+            // https://github.com/ckeditor/ckeditor5/issues/753
+            if (event.stop.called) {
+                evt.stop();
+            }
+        });
+    }
+    /**
+     * @inheritDoc
+     */
+    observe() { }
+    /**
+     * @inheritDoc
+     */
+    stopObserving() { }
+}

package/src/index.d.ts

@@ -1,13 +1,13 @@
-/**
- * @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 enter
- */
-export { default as Enter } from './enter';
-export { default as ShiftEnter } from './shiftenter';
-export type { ViewDocumentEnterEvent } from './enterobserver';
-export type { default as EnterCommand, EnterCommandAfterExecuteEvent } from './entercommand';
-export type { default as ShiftEnterCommand } from './shiftentercommand';
-import './augmentation';
+/**
+ * @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 enter
+ */
+export { default as Enter } from './enter';
+export { default as ShiftEnter } from './shiftenter';
+export type { ViewDocumentEnterEvent } from './enterobserver';
+export type { default as EnterCommand, EnterCommandAfterExecuteEvent } from './entercommand';
+export type { default as ShiftEnterCommand } from './shiftentercommand';
+import './augmentation';

package/src/index.js

@@ -1,10 +1,10 @@
-/**
- * @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 enter
- */
-export { default as Enter } from './enter';
-export { default as ShiftEnter } from './shiftenter';
-import './augmentation';
+/**
+ * @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 enter
+ */
+export { default as Enter } from './enter';
+export { default as ShiftEnter } from './shiftenter';
+import './augmentation';

package/src/shiftenter.d.ts

@@ -1,19 +1,19 @@
-/**
- * @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 { Plugin } from '@ckeditor/ckeditor5-core';
-/**
- * This plugin handles the <kbd>Shift</kbd>+<kbd>Enter</kbd> keystroke (soft line break) in the editor.
- *
- * See also the {@link module:enter/enter~Enter} plugin.
- *
- * For more information about this feature see the {@glink api/enter package page}.
- */
-export default class ShiftEnter extends Plugin {
-    /**
-     * @inheritDoc
-     */
-    static get pluginName(): "ShiftEnter";
-    init(): 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
+ */
+import { Plugin } from '@ckeditor/ckeditor5-core';
+/**
+ * This plugin handles the <kbd>Shift</kbd>+<kbd>Enter</kbd> keystroke (soft line break) in the editor.
+ *
+ * See also the {@link module:enter/enter~Enter} plugin.
+ *
+ * For more information about this feature see the {@glink api/enter package page}.
+ */
+export default class ShiftEnter extends Plugin {
+    /**
+     * @inheritDoc
+     */
+    static get pluginName(): "ShiftEnter";
+    init(): void;
+}

package/src/shiftenter.js

@@ -1,63 +1,63 @@
-/**
- * @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 enter/shiftenter
- */
-import ShiftEnterCommand from './shiftentercommand';
-import EnterObserver from './enterobserver';
-import { Plugin } from '@ckeditor/ckeditor5-core';
-/**
- * This plugin handles the <kbd>Shift</kbd>+<kbd>Enter</kbd> keystroke (soft line break) in the editor.
- *
- * See also the {@link module:enter/enter~Enter} plugin.
- *
- * For more information about this feature see the {@glink api/enter package page}.
- */
-export default class ShiftEnter extends Plugin {
-    /**
-     * @inheritDoc
-     */
-    static get pluginName() {
-        return 'ShiftEnter';
-    }
-    init() {
-        const editor = this.editor;
-        const schema = editor.model.schema;
-        const conversion = editor.conversion;
-        const view = editor.editing.view;
-        const viewDocument = view.document;
-        // Configure the schema.
-        schema.register('softBreak', {
-            allowWhere: '$text',
-            isInline: true
-        });
-        // Configure converters.
-        conversion.for('upcast')
-            .elementToElement({
-            model: 'softBreak',
-            view: 'br'
-        });
-        conversion.for('downcast')
-            .elementToElement({
-            model: 'softBreak',
-            view: (modelElement, { writer }) => writer.createEmptyElement('br')
-        });
-        view.addObserver(EnterObserver);
-        editor.commands.add('shiftEnter', new ShiftEnterCommand(editor));
-        this.listenTo(viewDocument, 'enter', (evt, data) => {
-            // When not in composition, we handle the action, so prevent the default one.
-            // When in composition, it's the browser who modify the DOM (renderer is disabled).
-            if (!viewDocument.isComposing) {
-                data.preventDefault();
-            }
-            // The hard enter key is handled by the Enter plugin.
-            if (!data.isSoft) {
-                return;
-            }
-            editor.execute('shiftEnter');
-            view.scrollToTheSelection();
-        }, { priority: 'low' });
-    }
-}
+/**
+ * @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 enter/shiftenter
+ */
+import ShiftEnterCommand from './shiftentercommand';
+import EnterObserver from './enterobserver';
+import { Plugin } from '@ckeditor/ckeditor5-core';
+/**
+ * This plugin handles the <kbd>Shift</kbd>+<kbd>Enter</kbd> keystroke (soft line break) in the editor.
+ *
+ * See also the {@link module:enter/enter~Enter} plugin.
+ *
+ * For more information about this feature see the {@glink api/enter package page}.
+ */
+export default class ShiftEnter extends Plugin {
+    /**
+     * @inheritDoc
+     */
+    static get pluginName() {
+        return 'ShiftEnter';
+    }
+    init() {
+        const editor = this.editor;
+        const schema = editor.model.schema;
+        const conversion = editor.conversion;
+        const view = editor.editing.view;
+        const viewDocument = view.document;
+        // Configure the schema.
+        schema.register('softBreak', {
+            allowWhere: '$text',
+            isInline: true
+        });
+        // Configure converters.
+        conversion.for('upcast')
+            .elementToElement({
+            model: 'softBreak',
+            view: 'br'
+        });
+        conversion.for('downcast')
+            .elementToElement({
+            model: 'softBreak',
+            view: (modelElement, { writer }) => writer.createEmptyElement('br')
+        });
+        view.addObserver(EnterObserver);
+        editor.commands.add('shiftEnter', new ShiftEnterCommand(editor));
+        this.listenTo(viewDocument, 'enter', (evt, data) => {
+            // When not in composition, we handle the action, so prevent the default one.
+            // When in composition, it's the browser who modify the DOM (renderer is disabled).
+            if (!viewDocument.isComposing) {
+                data.preventDefault();
+            }
+            // The hard enter key is handled by the Enter plugin.
+            if (!data.isSoft) {
+                return;
+            }
+            editor.execute('shiftEnter');
+            view.scrollToTheSelection();
+        }, { priority: 'low' });
+    }
+}

package/src/shiftentercommand.d.ts

@@ -1,34 +1,34 @@
-/**
- * @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 enter/shiftentercommand
- */
-import { Command } from '@ckeditor/ckeditor5-core';
-import type { Writer } from '@ckeditor/ckeditor5-engine';
-/**
- * ShiftEnter command. It is used by the {@link module:enter/shiftenter~ShiftEnter ShiftEnter feature} to handle
- * the <kbd>Shift</kbd>+<kbd>Enter</kbd> keystroke.
- */
-export default class ShiftEnterCommand extends Command {
-    /**
-     * @inheritDoc
-     */
-    execute(): void;
-    /**
-     * @inheritDoc
-     */
-    refresh(): void;
-}
-/**
- * Fired after the the {@link module:enter/shiftentercommand~ShiftEnterCommand} is finished executing.
- *
- * @eventName ~ShiftEnterCommand#afterExecute
- */
-export type ShiftEnterCommandAfterExecuteEvent = {
-    name: 'afterExecute';
-    args: [{
-        writer: Writer;
-    }];
-};
+/**
+ * @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 enter/shiftentercommand
+ */
+import { Command } from '@ckeditor/ckeditor5-core';
+import type { Writer } from '@ckeditor/ckeditor5-engine';
+/**
+ * ShiftEnter command. It is used by the {@link module:enter/shiftenter~ShiftEnter ShiftEnter feature} to handle
+ * the <kbd>Shift</kbd>+<kbd>Enter</kbd> keystroke.
+ */
+export default class ShiftEnterCommand extends Command {
+    /**
+     * @inheritDoc
+     */
+    execute(): void;
+    /**
+     * @inheritDoc
+     */
+    refresh(): void;
+}
+/**
+ * Fired after the the {@link module:enter/shiftentercommand~ShiftEnterCommand} is finished executing.
+ *
+ * @eventName ~ShiftEnterCommand#afterExecute
+ */
+export type ShiftEnterCommandAfterExecuteEvent = {
+    name: 'afterExecute';
+    args: [{
+        writer: Writer;
+    }];
+};

package/src/shiftentercommand.js

@@ -1,118 +1,118 @@
-/**
- * @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 enter/shiftentercommand
- */
-import { Command } from '@ckeditor/ckeditor5-core';
-import { getCopyOnEnterAttributes } from './utils';
-/**
- * ShiftEnter command. It is used by the {@link module:enter/shiftenter~ShiftEnter ShiftEnter feature} to handle
- * the <kbd>Shift</kbd>+<kbd>Enter</kbd> keystroke.
- */
-export default class ShiftEnterCommand extends Command {
-    /**
-     * @inheritDoc
-     */
-    execute() {
-        const model = this.editor.model;
-        const doc = model.document;
-        model.change(writer => {
-            softBreakAction(model, writer, doc.selection);
-            this.fire('afterExecute', { writer });
-        });
-    }
-    /**
-     * @inheritDoc
-     */
-    refresh() {
-        const model = this.editor.model;
-        const doc = model.document;
-        this.isEnabled = isEnabled(model.schema, doc.selection);
-    }
-}
-/**
- * Checks whether the ShiftEnter command should be enabled in the specified selection.
- */
-function isEnabled(schema, selection) {
-    // At this moment it is okay to support single range selections only.
-    // But in the future we may need to change that.
-    if (selection.rangeCount > 1) {
-        return false;
-    }
-    const anchorPos = selection.anchor;
-    // Check whether the break element can be inserted in the current selection anchor.
-    if (!anchorPos || !schema.checkChild(anchorPos, 'softBreak')) {
-        return false;
-    }
-    const range = selection.getFirstRange();
-    const startElement = range.start.parent;
-    const endElement = range.end.parent;
-    // Do not modify the content if selection is cross-limit elements.
-    if ((isInsideLimitElement(startElement, schema) || isInsideLimitElement(endElement, schema)) && startElement !== endElement) {
-        return false;
-    }
-    return true;
-}
-/**
- * Creates a break in the way that the <kbd>Shift</kbd>+<kbd>Enter</kbd> keystroke is expected to work.
- */
-function softBreakAction(model, writer, selection) {
-    const isSelectionEmpty = selection.isCollapsed;
-    const range = selection.getFirstRange();
-    const startElement = range.start.parent;
-    const endElement = range.end.parent;
-    const isContainedWithinOneElement = (startElement == endElement);
-    if (isSelectionEmpty) {
-        const attributesToCopy = getCopyOnEnterAttributes(model.schema, selection.getAttributes());
-        insertBreak(model, writer, range.end);
-        writer.removeSelectionAttribute(selection.getAttributeKeys());
-        writer.setSelectionAttribute(attributesToCopy);
-    }
-    else {
-        const leaveUnmerged = !(range.start.isAtStart && range.end.isAtEnd);
-        model.deleteContent(selection, { leaveUnmerged });
-        // Selection within one element:
-        //
-        // <h>x[xx]x</h>		-> <h>x^x</h>			-> <h>x<br>^x</h>
-        if (isContainedWithinOneElement) {
-            insertBreak(model, writer, selection.focus);
-        }
-        // Selection over multiple elements.
-        //
-        // <h>x[x</h><p>y]y<p>	-> <h>x^</h><p>y</p>	-> <h>x</h><p>^y</p>
-        //
-        // We chose not to insert a line break in this case because:
-        //
-        // * it's not a very common scenario,
-        // * it actually surprised me when I saw the "expected behavior" in real life.
-        //
-        // It's ok if the user will need to be more specific where they want the <br> to be inserted.
-        else {
-            // Move the selection to the 2nd element (last step of the example above).
-            if (leaveUnmerged) {
-                writer.setSelection(endElement, 0);
-            }
-        }
-    }
-}
-function insertBreak(model, writer, position) {
-    const breakLineElement = writer.createElement('softBreak');
-    model.insertContent(breakLineElement, position);
-    writer.setSelection(breakLineElement, 'after');
-}
-/**
- * Checks whether the specified `element` is a child of the limit element.
- *
- * Checking whether the `<p>` element is inside a limit element:
- *   - `<$root><p>Text.</p></$root> => false`
- *   - `<$root><limitElement><p>Text</p></limitElement></$root> => true`
- */
-function isInsideLimitElement(element, schema) {
-    // `$root` is a limit element but in this case is an invalid element.
-    if (element.is('rootElement')) {
-        return false;
-    }
-    return schema.isLimit(element) || isInsideLimitElement(element.parent, schema);
-}
+/**
+ * @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 enter/shiftentercommand
+ */
+import { Command } from '@ckeditor/ckeditor5-core';
+import { getCopyOnEnterAttributes } from './utils';
+/**
+ * ShiftEnter command. It is used by the {@link module:enter/shiftenter~ShiftEnter ShiftEnter feature} to handle
+ * the <kbd>Shift</kbd>+<kbd>Enter</kbd> keystroke.
+ */
+export default class ShiftEnterCommand extends Command {
+    /**
+     * @inheritDoc
+     */
+    execute() {
+        const model = this.editor.model;
+        const doc = model.document;
+        model.change(writer => {
+            softBreakAction(model, writer, doc.selection);
+            this.fire('afterExecute', { writer });
+        });
+    }
+    /**
+     * @inheritDoc
+     */
+    refresh() {
+        const model = this.editor.model;
+        const doc = model.document;
+        this.isEnabled = isEnabled(model.schema, doc.selection);
+    }
+}
+/**
+ * Checks whether the ShiftEnter command should be enabled in the specified selection.
+ */
+function isEnabled(schema, selection) {
+    // At this moment it is okay to support single range selections only.
+    // But in the future we may need to change that.
+    if (selection.rangeCount > 1) {
+        return false;
+    }
+    const anchorPos = selection.anchor;
+    // Check whether the break element can be inserted in the current selection anchor.
+    if (!anchorPos || !schema.checkChild(anchorPos, 'softBreak')) {
+        return false;
+    }
+    const range = selection.getFirstRange();
+    const startElement = range.start.parent;
+    const endElement = range.end.parent;
+    // Do not modify the content if selection is cross-limit elements.
+    if ((isInsideLimitElement(startElement, schema) || isInsideLimitElement(endElement, schema)) && startElement !== endElement) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Creates a break in the way that the <kbd>Shift</kbd>+<kbd>Enter</kbd> keystroke is expected to work.
+ */
+function softBreakAction(model, writer, selection) {
+    const isSelectionEmpty = selection.isCollapsed;
+    const range = selection.getFirstRange();
+    const startElement = range.start.parent;
+    const endElement = range.end.parent;
+    const isContainedWithinOneElement = (startElement == endElement);
+    if (isSelectionEmpty) {
+        const attributesToCopy = getCopyOnEnterAttributes(model.schema, selection.getAttributes());
+        insertBreak(model, writer, range.end);
+        writer.removeSelectionAttribute(selection.getAttributeKeys());
+        writer.setSelectionAttribute(attributesToCopy);
+    }
+    else {
+        const leaveUnmerged = !(range.start.isAtStart && range.end.isAtEnd);
+        model.deleteContent(selection, { leaveUnmerged });
+        // Selection within one element:
+        //
+        // <h>x[xx]x</h>		-> <h>x^x</h>			-> <h>x<br>^x</h>
+        if (isContainedWithinOneElement) {
+            insertBreak(model, writer, selection.focus);
+        }
+        // Selection over multiple elements.
+        //
+        // <h>x[x</h><p>y]y<p>	-> <h>x^</h><p>y</p>	-> <h>x</h><p>^y</p>
+        //
+        // We chose not to insert a line break in this case because:
+        //
+        // * it's not a very common scenario,
+        // * it actually surprised me when I saw the "expected behavior" in real life.
+        //
+        // It's ok if the user will need to be more specific where they want the <br> to be inserted.
+        else {
+            // Move the selection to the 2nd element (last step of the example above).
+            if (leaveUnmerged) {
+                writer.setSelection(endElement, 0);
+            }
+        }
+    }
+}
+function insertBreak(model, writer, position) {
+    const breakLineElement = writer.createElement('softBreak');
+    model.insertContent(breakLineElement, position);
+    writer.setSelection(breakLineElement, 'after');
+}
+/**
+ * Checks whether the specified `element` is a child of the limit element.
+ *
+ * Checking whether the `<p>` element is inside a limit element:
+ *   - `<$root><p>Text.</p></$root> => false`
+ *   - `<$root><limitElement><p>Text</p></limitElement></$root> => true`
+ */
+function isInsideLimitElement(element, schema) {
+    // `$root` is a limit element but in this case is an invalid element.
+    if (element.is('rootElement')) {
+        return false;
+    }
+    return schema.isLimit(element) || isInsideLimitElement(element.parent, schema);
+}