@ckeditor/ckeditor5-typing 40.0.0 → 40.2.0

package/src/utils/changebuffer.d.ts

@@ -1,103 +1,103 @@
-/**
- * @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 typing/utils/changebuffer
- */
-import type { Model, Batch } from '@ckeditor/ckeditor5-engine';
-/**
- * Change buffer allows to group atomic changes (like characters that have been typed) into
- * {@link module:engine/model/batch~Batch batches}.
- *
- * Batches represent single undo steps, hence changes added to one single batch are undone together.
- *
- * The buffer has a configurable limit of atomic changes that it can accommodate. After the limit was
- * exceeded (see {@link ~ChangeBuffer#input}), a new batch is created in {@link ~ChangeBuffer#batch}.
- *
- * To use the change buffer you need to let it know about the number of changes that were added to the batch:
- *
- * ```ts
- * const buffer = new ChangeBuffer( model, LIMIT );
- *
- * // Later on in your feature:
- * buffer.batch.insert( pos, insertedCharacters );
- * buffer.input( insertedCharacters.length );
- * ```
- */
-export default class ChangeBuffer {
-    /**
-     * The model instance.
-     */
-    readonly model: Model;
-    /**
-     * The maximum number of atomic changes which can be contained in one batch.
-     */
-    readonly limit: number;
-    /**
-     * Whether the buffer is locked. A locked buffer cannot be reset unless it gets unlocked.
-     */
-    private _isLocked;
-    /**
-     * The number of atomic changes in the buffer. Once it exceeds the {@link #limit},
-     * the {@link #batch batch} is set to a new one.
-     */
-    private _size;
-    /**
-     * The current batch instance.
-     */
-    private _batch;
-    /**
-     * The callback to document the change event which later needs to be removed.
-     */
-    private readonly _changeCallback;
-    /**
-     * The callback to document selection `change:attribute` and `change:range` events which resets the buffer.
-     */
-    private readonly _selectionChangeCallback;
-    /**
-     * Creates a new instance of the change buffer.
-     *
-     * @param limit The maximum number of atomic changes which can be contained in one batch.
-     */
-    constructor(model: Model, limit?: number);
-    /**
-     * The current batch to which a feature should add its operations. Once the {@link #size}
-     * is reached or exceeds the {@link #limit}, the batch is set to a new instance and the size is reset.
-     */
-    get batch(): Batch;
-    /**
-     * The number of atomic changes in the buffer. Once it exceeds the {@link #limit},
-     * the {@link #batch batch} is set to a new one.
-     */
-    get size(): number;
-    /**
-     * The input number of changes into the buffer. Once the {@link #size} is
-     * reached or exceeds the {@link #limit}, the batch is set to a new instance and the size is reset.
-     *
-     * @param changeCount The number of atomic changes to input.
-     */
-    input(changeCount: number): void;
-    /**
-     * Whether the buffer is locked. A locked buffer cannot be reset unless it gets unlocked.
-     */
-    get isLocked(): boolean;
-    /**
-     * Locks the buffer.
-     */
-    lock(): void;
-    /**
-     * Unlocks the buffer.
-     */
-    unlock(): void;
-    /**
-     * Destroys the buffer.
-     */
-    destroy(): void;
-    /**
-     * Resets the change buffer.
-     *
-     * @param ignoreLock Whether internal lock {@link #isLocked} should be ignored.
-     */
-    private _reset;
-}
+/**
+ * @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 typing/utils/changebuffer
+ */
+import type { Model, Batch } from '@ckeditor/ckeditor5-engine';
+/**
+ * Change buffer allows to group atomic changes (like characters that have been typed) into
+ * {@link module:engine/model/batch~Batch batches}.
+ *
+ * Batches represent single undo steps, hence changes added to one single batch are undone together.
+ *
+ * The buffer has a configurable limit of atomic changes that it can accommodate. After the limit was
+ * exceeded (see {@link ~ChangeBuffer#input}), a new batch is created in {@link ~ChangeBuffer#batch}.
+ *
+ * To use the change buffer you need to let it know about the number of changes that were added to the batch:
+ *
+ * ```ts
+ * const buffer = new ChangeBuffer( model, LIMIT );
+ *
+ * // Later on in your feature:
+ * buffer.batch.insert( pos, insertedCharacters );
+ * buffer.input( insertedCharacters.length );
+ * ```
+ */
+export default class ChangeBuffer {
+    /**
+     * The model instance.
+     */
+    readonly model: Model;
+    /**
+     * The maximum number of atomic changes which can be contained in one batch.
+     */
+    readonly limit: number;
+    /**
+     * Whether the buffer is locked. A locked buffer cannot be reset unless it gets unlocked.
+     */
+    private _isLocked;
+    /**
+     * The number of atomic changes in the buffer. Once it exceeds the {@link #limit},
+     * the {@link #batch batch} is set to a new one.
+     */
+    private _size;
+    /**
+     * The current batch instance.
+     */
+    private _batch;
+    /**
+     * The callback to document the change event which later needs to be removed.
+     */
+    private readonly _changeCallback;
+    /**
+     * The callback to document selection `change:attribute` and `change:range` events which resets the buffer.
+     */
+    private readonly _selectionChangeCallback;
+    /**
+     * Creates a new instance of the change buffer.
+     *
+     * @param limit The maximum number of atomic changes which can be contained in one batch.
+     */
+    constructor(model: Model, limit?: number);
+    /**
+     * The current batch to which a feature should add its operations. Once the {@link #size}
+     * is reached or exceeds the {@link #limit}, the batch is set to a new instance and the size is reset.
+     */
+    get batch(): Batch;
+    /**
+     * The number of atomic changes in the buffer. Once it exceeds the {@link #limit},
+     * the {@link #batch batch} is set to a new one.
+     */
+    get size(): number;
+    /**
+     * The input number of changes into the buffer. Once the {@link #size} is
+     * reached or exceeds the {@link #limit}, the batch is set to a new instance and the size is reset.
+     *
+     * @param changeCount The number of atomic changes to input.
+     */
+    input(changeCount: number): void;
+    /**
+     * Whether the buffer is locked. A locked buffer cannot be reset unless it gets unlocked.
+     */
+    get isLocked(): boolean;
+    /**
+     * Locks the buffer.
+     */
+    lock(): void;
+    /**
+     * Unlocks the buffer.
+     */
+    unlock(): void;
+    /**
+     * Destroys the buffer.
+     */
+    destroy(): void;
+    /**
+     * Resets the change buffer.
+     *
+     * @param ignoreLock Whether internal lock {@link #isLocked} should be ignored.
+     */
+    private _reset;
+}

package/src/utils/changebuffer.js

@@ -1,123 +1,123 @@
-/**
- * @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
- */
-/**
- * Change buffer allows to group atomic changes (like characters that have been typed) into
- * {@link module:engine/model/batch~Batch batches}.
- *
- * Batches represent single undo steps, hence changes added to one single batch are undone together.
- *
- * The buffer has a configurable limit of atomic changes that it can accommodate. After the limit was
- * exceeded (see {@link ~ChangeBuffer#input}), a new batch is created in {@link ~ChangeBuffer#batch}.
- *
- * To use the change buffer you need to let it know about the number of changes that were added to the batch:
- *
- * ```ts
- * const buffer = new ChangeBuffer( model, LIMIT );
- *
- * // Later on in your feature:
- * buffer.batch.insert( pos, insertedCharacters );
- * buffer.input( insertedCharacters.length );
- * ```
- */
-export default class ChangeBuffer {
-    /**
-     * Creates a new instance of the change buffer.
-     *
-     * @param limit The maximum number of atomic changes which can be contained in one batch.
-     */
-    constructor(model, limit = 20) {
-        /**
-         * The current batch instance.
-         */
-        this._batch = null;
-        this.model = model;
-        this._size = 0;
-        this.limit = limit;
-        this._isLocked = false;
-        // The function to be called in order to notify the buffer about batches which appeared in the document.
-        // The callback will check whether it is a new batch and in that case the buffer will be flushed.
-        //
-        // The reason why the buffer needs to be flushed whenever a new batch appears is that the changes added afterwards
-        // should be added to a new batch. For instance, when the user types, then inserts an image, and then types again,
-        // the characters typed after inserting the image should be added to a different batch than the characters typed before.
-        this._changeCallback = (evt, batch) => {
-            if (batch.isLocal && batch.isUndoable && batch !== this._batch) {
-                this._reset(true);
-            }
-        };
-        this._selectionChangeCallback = () => {
-            this._reset();
-        };
-        this.model.document.on('change', this._changeCallback);
-        this.model.document.selection.on('change:range', this._selectionChangeCallback);
-        this.model.document.selection.on('change:attribute', this._selectionChangeCallback);
-    }
-    /**
-     * The current batch to which a feature should add its operations. Once the {@link #size}
-     * is reached or exceeds the {@link #limit}, the batch is set to a new instance and the size is reset.
-     */
-    get batch() {
-        if (!this._batch) {
-            this._batch = this.model.createBatch({ isTyping: true });
-        }
-        return this._batch;
-    }
-    /**
-     * The number of atomic changes in the buffer. Once it exceeds the {@link #limit},
-     * the {@link #batch batch} is set to a new one.
-     */
-    get size() {
-        return this._size;
-    }
-    /**
-     * The input number of changes into the buffer. Once the {@link #size} is
-     * reached or exceeds the {@link #limit}, the batch is set to a new instance and the size is reset.
-     *
-     * @param changeCount The number of atomic changes to input.
-     */
-    input(changeCount) {
-        this._size += changeCount;
-        if (this._size >= this.limit) {
-            this._reset(true);
-        }
-    }
-    /**
-     * Whether the buffer is locked. A locked buffer cannot be reset unless it gets unlocked.
-     */
-    get isLocked() {
-        return this._isLocked;
-    }
-    /**
-     * Locks the buffer.
-     */
-    lock() {
-        this._isLocked = true;
-    }
-    /**
-     * Unlocks the buffer.
-     */
-    unlock() {
-        this._isLocked = false;
-    }
-    /**
-     * Destroys the buffer.
-     */
-    destroy() {
-        this.model.document.off('change', this._changeCallback);
-        this.model.document.selection.off('change:range', this._selectionChangeCallback);
-        this.model.document.selection.off('change:attribute', this._selectionChangeCallback);
-    }
-    /**
-     * Resets the change buffer.
-     *
-     * @param ignoreLock Whether internal lock {@link #isLocked} should be ignored.
-     */
-    _reset(ignoreLock = false) {
-        if (!this.isLocked || ignoreLock) {
-            this._batch = null;
-            this._size = 0;
-        }
-    }
-}
+/**
+ * @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
+ */
+/**
+ * Change buffer allows to group atomic changes (like characters that have been typed) into
+ * {@link module:engine/model/batch~Batch batches}.
+ *
+ * Batches represent single undo steps, hence changes added to one single batch are undone together.
+ *
+ * The buffer has a configurable limit of atomic changes that it can accommodate. After the limit was
+ * exceeded (see {@link ~ChangeBuffer#input}), a new batch is created in {@link ~ChangeBuffer#batch}.
+ *
+ * To use the change buffer you need to let it know about the number of changes that were added to the batch:
+ *
+ * ```ts
+ * const buffer = new ChangeBuffer( model, LIMIT );
+ *
+ * // Later on in your feature:
+ * buffer.batch.insert( pos, insertedCharacters );
+ * buffer.input( insertedCharacters.length );
+ * ```
+ */
+export default class ChangeBuffer {
+    /**
+     * Creates a new instance of the change buffer.
+     *
+     * @param limit The maximum number of atomic changes which can be contained in one batch.
+     */
+    constructor(model, limit = 20) {
+        /**
+         * The current batch instance.
+         */
+        this._batch = null;
+        this.model = model;
+        this._size = 0;
+        this.limit = limit;
+        this._isLocked = false;
+        // The function to be called in order to notify the buffer about batches which appeared in the document.
+        // The callback will check whether it is a new batch and in that case the buffer will be flushed.
+        //
+        // The reason why the buffer needs to be flushed whenever a new batch appears is that the changes added afterwards
+        // should be added to a new batch. For instance, when the user types, then inserts an image, and then types again,
+        // the characters typed after inserting the image should be added to a different batch than the characters typed before.
+        this._changeCallback = (evt, batch) => {
+            if (batch.isLocal && batch.isUndoable && batch !== this._batch) {
+                this._reset(true);
+            }
+        };
+        this._selectionChangeCallback = () => {
+            this._reset();
+        };
+        this.model.document.on('change', this._changeCallback);
+        this.model.document.selection.on('change:range', this._selectionChangeCallback);
+        this.model.document.selection.on('change:attribute', this._selectionChangeCallback);
+    }
+    /**
+     * The current batch to which a feature should add its operations. Once the {@link #size}
+     * is reached or exceeds the {@link #limit}, the batch is set to a new instance and the size is reset.
+     */
+    get batch() {
+        if (!this._batch) {
+            this._batch = this.model.createBatch({ isTyping: true });
+        }
+        return this._batch;
+    }
+    /**
+     * The number of atomic changes in the buffer. Once it exceeds the {@link #limit},
+     * the {@link #batch batch} is set to a new one.
+     */
+    get size() {
+        return this._size;
+    }
+    /**
+     * The input number of changes into the buffer. Once the {@link #size} is
+     * reached or exceeds the {@link #limit}, the batch is set to a new instance and the size is reset.
+     *
+     * @param changeCount The number of atomic changes to input.
+     */
+    input(changeCount) {
+        this._size += changeCount;
+        if (this._size >= this.limit) {
+            this._reset(true);
+        }
+    }
+    /**
+     * Whether the buffer is locked. A locked buffer cannot be reset unless it gets unlocked.
+     */
+    get isLocked() {
+        return this._isLocked;
+    }
+    /**
+     * Locks the buffer.
+     */
+    lock() {
+        this._isLocked = true;
+    }
+    /**
+     * Unlocks the buffer.
+     */
+    unlock() {
+        this._isLocked = false;
+    }
+    /**
+     * Destroys the buffer.
+     */
+    destroy() {
+        this.model.document.off('change', this._changeCallback);
+        this.model.document.selection.off('change:range', this._selectionChangeCallback);
+        this.model.document.selection.off('change:attribute', this._selectionChangeCallback);
+    }
+    /**
+     * Resets the change buffer.
+     *
+     * @param ignoreLock Whether internal lock {@link #isLocked} should be ignored.
+     */
+    _reset(ignoreLock = false) {
+        if (!this.isLocked || ignoreLock) {
+            this._batch = null;
+            this._size = 0;
+        }
+    }
+}

package/src/utils/findattributerange.d.ts

@@ -1,33 +1,33 @@
-/**
- * @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 typing/utils/findattributerange
- */
-import type { Position, Model, Range } from '@ckeditor/ckeditor5-engine';
-/**
- * Returns a model range that covers all consecutive nodes with the same `attributeName` and its `value`
- * that intersect the given `position`.
- *
- * It can be used e.g. to get the entire range on which the `linkHref` attribute needs to be changed when having a
- * selection inside a link.
- *
- * @param position The start position.
- * @param attributeName The attribute name.
- * @param value The attribute value.
- * @param model The model instance.
- * @returns The link range.
- */
-export default function findAttributeRange(position: Position, attributeName: string, value: unknown, model: Model): Range;
-/**
- * Walks forward or backward (depends on the `lookBack` flag), node by node, as long as they have the same attribute value
- * and returns a position just before or after (depends on the `lookBack` flag) the last matched node.
- *
- * @param position The start position.
- * @param attributeName The attribute name.
- * @param value The attribute value.
- * @param lookBack Whether the walk direction is forward (`false`) or backward (`true`).
- * @returns The position just before the last matched node.
- */
-export declare function findAttributeRangeBound(position: Position, attributeName: string, value: unknown, lookBack: boolean, model: Model): Position;
+/**
+ * @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 typing/utils/findattributerange
+ */
+import type { Position, Model, Range } from '@ckeditor/ckeditor5-engine';
+/**
+ * Returns a model range that covers all consecutive nodes with the same `attributeName` and its `value`
+ * that intersect the given `position`.
+ *
+ * It can be used e.g. to get the entire range on which the `linkHref` attribute needs to be changed when having a
+ * selection inside a link.
+ *
+ * @param position The start position.
+ * @param attributeName The attribute name.
+ * @param value The attribute value.
+ * @param model The model instance.
+ * @returns The link range.
+ */
+export default function findAttributeRange(position: Position, attributeName: string, value: unknown, model: Model): Range;
+/**
+ * Walks forward or backward (depends on the `lookBack` flag), node by node, as long as they have the same attribute value
+ * and returns a position just before or after (depends on the `lookBack` flag) the last matched node.
+ *
+ * @param position The start position.
+ * @param attributeName The attribute name.
+ * @param value The attribute value.
+ * @param lookBack Whether the walk direction is forward (`false`) or backward (`true`).
+ * @returns The position just before the last matched node.
+ */
+export declare function findAttributeRangeBound(position: Position, attributeName: string, value: unknown, lookBack: boolean, model: Model): Position;

package/src/utils/findattributerange.js

@@ -1,41 +1,41 @@
-/**
- * @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
- */
-/**
- * Returns a model range that covers all consecutive nodes with the same `attributeName` and its `value`
- * that intersect the given `position`.
- *
- * It can be used e.g. to get the entire range on which the `linkHref` attribute needs to be changed when having a
- * selection inside a link.
- *
- * @param position The start position.
- * @param attributeName The attribute name.
- * @param value The attribute value.
- * @param model The model instance.
- * @returns The link range.
- */
-export default function findAttributeRange(position, attributeName, value, model) {
-    return model.createRange(findAttributeRangeBound(position, attributeName, value, true, model), findAttributeRangeBound(position, attributeName, value, false, model));
-}
-/**
- * Walks forward or backward (depends on the `lookBack` flag), node by node, as long as they have the same attribute value
- * and returns a position just before or after (depends on the `lookBack` flag) the last matched node.
- *
- * @param position The start position.
- * @param attributeName The attribute name.
- * @param value The attribute value.
- * @param lookBack Whether the walk direction is forward (`false`) or backward (`true`).
- * @returns The position just before the last matched node.
- */
-export function findAttributeRangeBound(position, attributeName, value, lookBack, model) {
-    // Get node before or after position (depends on `lookBack` flag).
-    // When position is inside text node then start searching from text node.
-    let node = position.textNode || (lookBack ? position.nodeBefore : position.nodeAfter);
-    let lastNode = null;
-    while (node && node.getAttribute(attributeName) == value) {
-        lastNode = node;
-        node = lookBack ? node.previousSibling : node.nextSibling;
-    }
-    return lastNode ? model.createPositionAt(lastNode, lookBack ? 'before' : 'after') : position;
-}
+/**
+ * @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
+ */
+/**
+ * Returns a model range that covers all consecutive nodes with the same `attributeName` and its `value`
+ * that intersect the given `position`.
+ *
+ * It can be used e.g. to get the entire range on which the `linkHref` attribute needs to be changed when having a
+ * selection inside a link.
+ *
+ * @param position The start position.
+ * @param attributeName The attribute name.
+ * @param value The attribute value.
+ * @param model The model instance.
+ * @returns The link range.
+ */
+export default function findAttributeRange(position, attributeName, value, model) {
+    return model.createRange(findAttributeRangeBound(position, attributeName, value, true, model), findAttributeRangeBound(position, attributeName, value, false, model));
+}
+/**
+ * Walks forward or backward (depends on the `lookBack` flag), node by node, as long as they have the same attribute value
+ * and returns a position just before or after (depends on the `lookBack` flag) the last matched node.
+ *
+ * @param position The start position.
+ * @param attributeName The attribute name.
+ * @param value The attribute value.
+ * @param lookBack Whether the walk direction is forward (`false`) or backward (`true`).
+ * @returns The position just before the last matched node.
+ */
+export function findAttributeRangeBound(position, attributeName, value, lookBack, model) {
+    // Get node before or after position (depends on `lookBack` flag).
+    // When position is inside text node then start searching from text node.
+    let node = position.textNode || (lookBack ? position.nodeBefore : position.nodeAfter);
+    let lastNode = null;
+    while (node && node.getAttribute(attributeName) == value) {
+        lastNode = node;
+        node = lookBack ? node.previousSibling : node.nextSibling;
+    }
+    return lastNode ? model.createPositionAt(lastNode, lookBack ? 'before' : 'after') : position;
+}