@progress/kendo-editor-common 1.11.9-dev.202412020819 → 1.11.9-develop.1

package/dist/es2015/utils.js

@@ -1,8 +1,8 @@
-import { Node, Fragment } from 'prosemirror-model';
-import { TextSelection, AllSelection, NodeSelection } from 'prosemirror-state';
+import { Node } from 'prosemirror-model';
+import { NodeSelection, TextSelection, AllSelection } from 'prosemirror-state';
 import { parseInlineStyles } from '@progress/kendo-common';
-import { parseContent } from './source';
-export const changeStylesString = (styleText, newStyle) => {
+
+const changeStylesString = (styleText, newStyle) => {
     const styleToChange = newStyle.style;
     const regExp = newStyle.value;
     const newValue = newStyle.newValue;
@@ -27,7 +27,7 @@ export const changeStylesString = (styleText, newStyle) => {
     };
 };
 const reAnyValue = /^.+$/;
-export function setNodeStyle(nodeAttrs, styleType, value) {
+function setNodeStyle(nodeAttrs, styleType, value) {
     let attrs;
     if (new RegExp('[^-]?' + styleType + ':').test(nodeAttrs.style || '')) {
         const { style } = changeStylesString(nodeAttrs.style || '', { style: styleType, value: reAnyValue, newValue: value });
@@ -44,7 +44,7 @@ export function setNodeStyle(nodeAttrs, styleType, value) {
 /**
  * Determines if a given node type can be inserted at the current cursor position.
  */
-export const canInsert = (state, nodeType) => {
+const canInsert = (state, nodeType) => {
     const $from = state.selection.$from;
     for (let d = $from.depth; d >= 0; d--) {
         const index = $from.index(d);
@@ -71,12 +71,12 @@ const findNthParentNode = (predicate, depth = 1) => {
         }
     };
 };
-export const findNthParentNodeOfType = (nodeType, depth = 1) => {
+const findNthParentNodeOfType = (nodeType, depth = 1) => {
     return (selection) => {
         return findNthParentNode((node) => getTypeName(node) === getTypeName(nodeType), depth)(selection);
     };
 };
-export function parentNode(pos, predicate) {
+function parentNode(pos, predicate) {
     for (let depth = pos.depth; depth > 0; depth--) {
         const node = pos.node(depth);
         if (predicate(node)) {
@@ -97,7 +97,7 @@ const filterEmptyAttrs = (attrs) => {
 /**
  * Inserts the given node at the place of current selection.
  */
-export const insertNode = (node, scrollIntoView) => (state, dispatch) => {
+const insertNode = (node, scrollIntoView) => (state, dispatch) => {
     const { selection, tr } = state;
     if (selection instanceof NodeSelection
         && selection.node.type.name === node.type.name
@@ -113,12 +113,7 @@ export const insertNode = (node, scrollIntoView) => (state, dispatch) => {
     }
     dispatch(tr);
 };
-export const hasSameMarkup = (dom1, dom2, schema, parseOptions) => {
-    const fragment1 = Fragment.from(parseContent(dom1, schema, parseOptions));
-    const fragment2 = Fragment.from(parseContent(dom2, schema, parseOptions));
-    return fragment1.eq(fragment2);
-};
-export const getSelectionText = (state) => {
+const getSelectionText = (state) => {
     const sel = state.selection;
     if (sel instanceof TextSelection || sel instanceof AllSelection) {
         const fragment = sel.content().content;
@@ -126,7 +121,7 @@ export const getSelectionText = (state) => {
     }
     return '';
 };
-export const getNodeFromSelection = (state) => {
+const getNodeFromSelection = (state) => {
     if (state.selection instanceof NodeSelection) {
         return state.selection.node;
     }
@@ -139,7 +134,7 @@ export const getNodeFromSelection = (state) => {
  * Useful for values of the inputs of Link and Find&Replace dialogs where the inputs value has been retrieved from the selection and
  * should be single line text only.
  */
-export const selectedLineTextOnly = (state) => {
+const selectedLineTextOnly = (state) => {
     let result = '', hasLeafs = false;
     const { selection, doc } = state;
     const { $from, $to, from, to } = selection;
@@ -156,13 +151,13 @@ export const selectedLineTextOnly = (state) => {
 /**
  * Used by ViewHtml/ViewSource dialogs for making the HTML more readable.
  */
-export const indentHtml = (content) => {
+const indentHtml = (content) => {
     return content.replace(/<\/(p|li|ul|ol|h[1-6]|table|tr|td|th)>/ig, '</$1>\n')
         .replace(/<(ul|ol)([^>]*)><li/ig, '<$1$2>\n<li')
         .replace(/<br \/>/ig, '<br />\n')
         .replace(/\n$/, '');
 };
-export const shallowEqual = (object1, object2) => {
+const shallowEqual = (object1, object2) => {
     const keys1 = Object.keys(object1);
     const keys2 = Object.keys(object2);
     return keys1.length === keys2.length &&
@@ -173,7 +168,7 @@ const applyToWordDefault = { before: /[^ !,?.\[\]{}()]+$/i, after: /^[^ !,?.\[\]
  * if options.applyToWord is set, expands the selection to the word where the cursor is and
  * returns modified state and dispatch.
  */
-export const expandSelection = (state, dispatch, options) => {
+const expandSelection = (state, dispatch, options) => {
     if (!options.applyToWord || !state.selection.empty) {
         return { state, dispatch };
     }
@@ -249,16 +244,16 @@ export const expandSelection = (state, dispatch, options) => {
  * const command = expandToWordWrap(toggleInlineFormat, {...bold, applyToWord );
  * command(view.state, view.dispatch);
  */
-export const expandToWordWrap = (command, options) => {
+const expandToWordWrap = (command, options) => {
     return (state, dispatch) => {
         const { state: cmdState, dispatch: cmdDispatch } = expandSelection(state, dispatch, options);
         return command(options)(cmdState, cmdDispatch);
     };
 };
-export const parseStyle = (styleText) => {
+const parseStyle = (styleText) => {
     return parseInlineStyles(styleText);
 };
-export const applyStyle = (styleText, styleType, styleValue) => {
+const applyStyle = (styleText, styleType, styleValue) => {
     const styles = parseStyle(styleText);
     styles[styleType] = styleValue;
     const result = Object.keys(styles)
@@ -267,7 +262,7 @@ export const applyStyle = (styleText, styleType, styleValue) => {
         .join('; ');
     return result ? result + ';' : null;
 };
-export const setStyleAttr = (element, styleString) => {
+const setStyleAttr = (element, styleString) => {
     const styles = parseStyle(styleString);
     for (const style in styles) {
         if (style && typeof element.style[style] !== 'undefined') {
@@ -275,7 +270,7 @@ export const setStyleAttr = (element, styleString) => {
         }
     }
 };
-export const setAttribute = (node, attrName, value) => {
+const setAttribute = (node, attrName, value) => {
     const current = node.getAttribute(attrName);
     if (value !== undefined && value !== current) {
         if (attrName === 'style') {
@@ -290,3 +285,5 @@ export const setAttribute = (node, attrName, value) => {
         node.removeAttribute(attrName);
     }
 };
+
+export { applyStyle, canInsert, changeStylesString, expandSelection, expandToWordWrap, findNthParentNodeOfType, getNodeFromSelection, getSelectionText, indentHtml, insertNode, parentNode, parseStyle, selectedLineTextOnly, setAttribute, setNodeStyle, setStyleAttr, shallowEqual };

package/dist/npm/DOMSerializer.js

@@ -1,28 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DOMSerializer = void 0;
-var utils_1 = require("./utils");
-var DOMSerializer = /** @class */ (function () {
-    /// Create a serializer. `nodes` should map node names to functions
-    /// that take a node and return a description of the corresponding
-    /// DOM. `marks` does the same for mark names, but also gets an
-    /// argument that tells it whether the mark's content is block or
-    /// inline content (for typical use, it'll always be inline). A mark
-    /// serializer may be `null` to indicate that marks of that type
-    /// should not be serialized.
-    function DOMSerializer(
-    /// The node serialization functions.
-    nodes, 
-    /// The mark serialization functions.
-    marks) {
-        this.nodes = nodes;
-        this.marks = marks;
-    }
+'use strict';
+
+var utils = require('./utils.js');
+
+class DOMSerializer {
     /// Render an [output spec](#model.DOMOutputSpec) to a DOM node. If
     /// the spec has a hole (zero) in it, `contentDOM` will point at the
     /// node with the hole.
-    DOMSerializer.renderSpec = function (docum, structure, xmlNS) {
-        if (xmlNS === void 0) { xmlNS = null; }
+    static renderSpec(docum, structure, xmlNS = null) {
         if (typeof structure === 'string') {
             return { dom: docum.createTextNode(structure) };
         }
@@ -32,38 +16,38 @@ var DOMSerializer = /** @class */ (function () {
         if (structure.dom && structure.dom.nodeType != null) {
             return structure;
         }
-        var tagName = structure[0], space = tagName.indexOf(' ');
+        let tagName = structure[0], space = tagName.indexOf(' ');
         if (space > 0) {
             xmlNS = tagName.slice(0, space);
             tagName = tagName.slice(space + 1);
         }
-        var contentDOM;
-        var dom = (xmlNS ? docum.createElementNS(xmlNS, tagName) : docum.createElement(tagName));
-        var attrs = structure[1], start = 1;
+        let contentDOM;
+        const dom = (xmlNS ? docum.createElementNS(xmlNS, tagName) : docum.createElement(tagName));
+        let attrs = structure[1], start = 1;
         if (attrs && typeof attrs === 'object' && attrs.nodeType == null && !Array.isArray(attrs)) {
             start = 2;
-            for (var name_1 in attrs) {
-                if (attrs[name_1] != null) {
-                    space = name_1.indexOf(' ');
+            for (const name in attrs) {
+                if (attrs[name] != null) {
+                    space = name.indexOf(' ');
                     if (space > 0) {
-                        dom.setAttributeNS(name_1.slice(0, space), name_1.slice(space + 1), attrs[name_1]);
+                        dom.setAttributeNS(name.slice(0, space), name.slice(space + 1), attrs[name]);
                     }
                     else {
-                        (0, utils_1.setAttribute)(dom, name_1, attrs[name_1]);
+                        utils.setAttribute(dom, name, attrs[name]);
                     }
                 }
             }
         }
-        for (var i = start; i < structure.length; i++) {
-            var child = structure[i];
+        for (let i = start; i < structure.length; i++) {
+            const child = structure[i];
             if (child === 0) {
                 if (i < structure.length - 1 || i > start) {
                     throw new RangeError('Content hole must be the only child of its parent node');
                 }
-                return { dom: dom, contentDOM: dom };
+                return { dom, contentDOM: dom };
             }
             else {
-                var _a = DOMSerializer.renderSpec(docum, child, xmlNS), inner = _a.dom, innerContent = _a.contentDOM;
+                const { dom: inner, contentDOM: innerContent } = DOMSerializer.renderSpec(docum, child, xmlNS);
                 dom.appendChild(inner);
                 if (innerContent) {
                     if (contentDOM) {
@@ -73,44 +57,57 @@ var DOMSerializer = /** @class */ (function () {
                 }
             }
         }
-        return { dom: dom, contentDOM: contentDOM };
-    };
+        return { dom, contentDOM };
+    }
     /// Build a serializer using the [`toDOM`](#model.NodeSpec.toDOM)
     /// properties in a schema's node and mark specs.
-    DOMSerializer.fromSchema = function (schema) {
+    static fromSchema(schema) {
         return schema.cached.domSerializer ||
             (schema.cached.domSerializer = new DOMSerializer(this.nodesFromSchema(schema), this.marksFromSchema(schema)));
-    };
+    }
     /// Gather the serializers in a schema's node specs into an object.
     /// This can be useful as a base to build a custom serializer from.
-    DOMSerializer.nodesFromSchema = function (schema) {
-        var result = gatherToDOM(schema.nodes);
+    static nodesFromSchema(schema) {
+        const result = gatherToDOM(schema.nodes);
         if (!result.text) {
-            result.text = function (node) { return node.text; };
+            result.text = node => node.text;
         }
         return result;
-    };
+    }
     /// Gather the serializers in a schema's mark specs into an object.
-    DOMSerializer.marksFromSchema = function (schema) {
+    static marksFromSchema(schema) {
         return gatherToDOM(schema.marks);
-    };
+    }
+    /// Create a serializer. `nodes` should map node names to functions
+    /// that take a node and return a description of the corresponding
+    /// DOM. `marks` does the same for mark names, but also gets an
+    /// argument that tells it whether the mark's content is block or
+    /// inline content (for typical use, it'll always be inline). A mark
+    /// serializer may be `null` to indicate that marks of that type
+    /// should not be serialized.
+    constructor(
+    /// The node serialization functions.
+    nodes, 
+    /// The mark serialization functions.
+    marks) {
+        this.nodes = nodes;
+        this.marks = marks;
+    }
     /// Serialize the content of this fragment to a DOM fragment. When
     /// not in the browser, the `document` option, containing a DOM
     /// document, should be passed so that the serializer can create
     /// nodes.
-    DOMSerializer.prototype.serializeFragment = function (fragment, options, target) {
-        var _this = this;
-        if (options === void 0) { options = {}; }
+    serializeFragment(fragment, options = {}, target) {
         if (!target) {
             target = doc(options).createDocumentFragment();
         }
-        var top = target, active = [];
-        fragment.forEach(function (node) {
+        let top = target, active = [];
+        fragment.forEach(node => {
             if (active.length || node.marks.length) {
-                var keep = 0, rendered = 0;
+                let keep = 0, rendered = 0;
                 while (keep < active.length && rendered < node.marks.length) {
-                    var next = node.marks[rendered];
-                    if (!_this.marks[next.type.name]) {
+                    const next = node.marks[rendered];
+                    if (!this.marks[next.type.name]) {
                         rendered++;
                         continue;
                     }
@@ -124,8 +121,8 @@ var DOMSerializer = /** @class */ (function () {
                     top = active.pop()[1];
                 }
                 while (rendered < node.marks.length) {
-                    var add = node.marks[rendered++];
-                    var markDOM = _this.serializeMark(add, node.isInline, options);
+                    const add = node.marks[rendered++];
+                    const markDOM = this.serializeMark(add, node.isInline, options);
                     if (markDOM) {
                         active.push([add, top]);
                         top.appendChild(markDOM.dom);
@@ -133,36 +130,34 @@ var DOMSerializer = /** @class */ (function () {
                     }
                 }
             }
-            top.appendChild(_this.serializeNodeInner(node, options));
+            top.appendChild(this.serializeNodeInner(node, options));
         });
         return target;
-    };
+    }
     /// Serialize this node to a DOM node. This can be useful when you
     /// need to serialize a part of a document, as opposed to the whole
     /// document. To serialize a whole document, use
     /// [`serializeFragment`](#model.DOMSerializer.serializeFragment) on
     /// its [content](#model.Node.content).
-    DOMSerializer.prototype.serializeNode = function (node, options) {
-        if (options === void 0) { options = {}; }
-        var dom = this.serializeNodeInner(node, options);
-        for (var i = node.marks.length - 1; i >= 0; i--) {
-            var wrap = this.serializeMark(node.marks[i], node.isInline, options);
+    serializeNode(node, options = {}) {
+        let dom = this.serializeNodeInner(node, options);
+        for (let i = node.marks.length - 1; i >= 0; i--) {
+            const wrap = this.serializeMark(node.marks[i], node.isInline, options);
             if (wrap) {
                 (wrap.contentDOM || wrap.dom).appendChild(dom);
                 dom = wrap.dom;
             }
         }
         return dom;
-    };
+    }
     /// @internal
-    DOMSerializer.prototype.serializeMark = function (mark, inline, options) {
-        if (options === void 0) { options = {}; }
-        var toDOM = this.marks[mark.type.name];
+    serializeMark(mark, inline, options = {}) {
+        const toDOM = this.marks[mark.type.name];
         return toDOM && DOMSerializer.renderSpec(doc(options), toDOM(mark, inline));
-    };
+    }
     /// @internal
-    DOMSerializer.prototype.serializeNodeInner = function (node, options) {
-        var _a = DOMSerializer.renderSpec(doc(options), this.nodes[node.type.name](node)), dom = _a.dom, contentDOM = _a.contentDOM;
+    serializeNodeInner(node, options) {
+        const { dom, contentDOM } = DOMSerializer.renderSpec(doc(options), this.nodes[node.type.name](node));
         if (contentDOM) {
             if (node.isLeaf) {
                 throw new RangeError('Content hole not allowed in a leaf node spec');
@@ -170,17 +165,15 @@ var DOMSerializer = /** @class */ (function () {
             this.serializeFragment(node.content, options, contentDOM);
         }
         return dom;
-    };
-    return DOMSerializer;
-}());
-exports.DOMSerializer = DOMSerializer;
+    }
+}
 function gatherToDOM(obj) {
-    var result = {};
-    for (var name_2 in obj) {
-        if (obj[name_2]) {
-            var toDOM = obj[name_2].spec.toDOM;
+    const result = {};
+    for (const name in obj) {
+        if (obj[name]) {
+            const toDOM = obj[name].spec.toDOM;
             if (toDOM) {
-                result[name_2] = toDOM;
+                result[name] = toDOM;
             }
         }
     }
@@ -189,3 +182,5 @@ function gatherToDOM(obj) {
 function doc(options) {
     return options.document || window.document;
 }
+
+exports.DOMSerializer = DOMSerializer;

package/dist/npm/align.d.ts

@@ -1,10 +1,13 @@
 import { EditorState } from 'prosemirror-state';
-import { AlignRule } from './config/align-rules';
-import { Command } from './types/command';
+import { AlignRule } from './config/align-rules.js';
+import { Command } from './types/command.js';
+
 /**
  * Aligning block elements in the selection.
  *
  * @returns {boolean} - Returns true if any alignment is applied.
  */
-export declare const alignBlocks: (actions: Array<AlignRule>, commandName?: string) => Command;
-export declare const isAligned: (state: EditorState, actions: Array<AlignRule>) => boolean;
+declare const alignBlocks: (actions: Array<AlignRule>, commandName?: string) => Command;
+declare const isAligned: (state: EditorState, actions: Array<AlignRule>) => boolean;
+
+export { alignBlocks, isAligned };

package/dist/npm/align.js

@@ -1,45 +1,46 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isAligned = exports.alignBlocks = void 0;
-var blockNode_1 = require("./blockNode");
+'use strict';
+
+var blockNode = require('./blockNode.js');
+
 /**
  * Aligning block elements in the selection.
  *
  * @returns {boolean} - Returns true if any alignment is applied.
  */
-var alignBlocks = function (actions, commandName) { return function (state, dispatch) {
-    var blocks = (0, blockNode_1.blockNodes)(state);
-    var tr = state.tr;
+const alignBlocks = (actions, commandName) => (state, dispatch) => {
+    const blocks = blockNode.blockNodes(state);
+    const tr = state.tr;
     tr.setMeta('commandName', commandName);
-    blocks.forEach(function (node) {
+    blocks.forEach(node => {
         if (node.type.isTextblock) {
-            var action = actions.find(function (n) { return n.node === node.type.name; });
+            const action = actions.find(n => n.node === node.type.name);
             if (action) {
-                var newAttrs = (0, blockNode_1.addStyles)(node, action.style);
-                (0, blockNode_1.changeTextBlock)(tr, node, node.type, newAttrs);
+                const newAttrs = blockNode.addStyles(node, action.style);
+                blockNode.changeTextBlock(tr, node, node.type, newAttrs);
             }
         }
     });
-    var result = tr.docChanged;
+    const result = tr.docChanged;
     if (result) {
         dispatch(tr.scrollIntoView());
     }
     return result;
-}; };
-exports.alignBlocks = alignBlocks;
-var isAligned = function (state, actions) {
-    var blocks = (0, blockNode_1.blockNodes)(state);
-    var result = false;
-    blocks.forEach(function (node) {
+};
+const isAligned = (state, actions) => {
+    const blocks = blockNode.blockNodes(state);
+    let result = false;
+    blocks.forEach(node => {
         if (!result && node.type.isTextblock && node.attrs.style) {
-            var action = actions.find(function (a) { return a.node === node.type.name; });
+            const action = actions.find(a => a.node === node.type.name);
             if (action) {
-                result = action.style.every(function (style) {
-                    return !!style.value && new RegExp("".concat(style.name, ":\\s?").concat(style.value), 'i').test(node.attrs.style);
+                result = action.style.every(style => {
+                    return !!style.value && new RegExp(`${style.name}:\\s?${style.value}`, 'i').test(node.attrs.style);
                 });
             }
         }
     });
     return result;
 };
+
+exports.alignBlocks = alignBlocks;
 exports.isAligned = isAligned;

package/dist/npm/blockNode.d.ts

@@ -1,13 +1,14 @@
-import { NodeType, Node } from 'prosemirror-model';
-import { EditorState, Transaction, Selection } from 'prosemirror-state';
-import { CleanFormattingOptions } from './cleanFormatting';
+import { Node, NodeType } from 'prosemirror-model';
+import { Transaction, EditorState, Selection } from 'prosemirror-state';
+import { CleanFormattingOptions } from './cleanFormatting.js';
+
 /**
  * Changes the type or the attributes of the passed node.
  *
  * @example
  * See `cleanTextBlockFormatting` or `formatBlockElements` function.
  */
-export declare const changeTextBlock: (tr: Transaction, node: Node, nodeType: NodeType, attrs?: {
+declare const changeTextBlock: (tr: Transaction, node: Node, nodeType: NodeType, attrs?: {
     [key: string]: any;
 }) => boolean;
 /**
@@ -16,13 +17,13 @@ export declare const changeTextBlock: (tr: Transaction, node: Node, nodeType: No
  * @example
  * See `cleanTextBlockFormatting` function.
  */
-export declare const blockNodes: (state: EditorState | {
+declare const blockNodes: (state: EditorState | {
     doc: Node;
     selection: Selection;
 }, options?: {
     blocksInSelection: boolean;
 }) => Array<Node>;
-export declare const formatBlockElements: (value: 'p' | 'blockquote' | 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6', commandName?: string) => (state: any, dispatch: any) => any;
+declare const formatBlockElements: (value: "p" | "blockquote" | "h1" | "h2" | "h3" | "h4" | "h5" | "h6", commandName?: string) => (state: any, dispatch: any) => any;
 /**
  * Removes the style and class attributes of text block elements.
  * Requires to dispatch the transaction.
@@ -30,17 +31,15 @@ export declare const formatBlockElements: (value: 'p' | 'blockquote' | 'h1' | 'h
  * @example
  * See `cleanFormatting` function.
  */
-export declare const cleanTextBlockFormatting: (tr: Transaction, options?: CleanFormattingOptions) => void;
-export declare const getBlockFormats: (state: EditorState) => Array<string>;
-export declare const addStyles: (node: Node, stylesToApply: Array<{
-    name: string;
-    value: string;
-}>) => {};
-export declare const hasNode: (state: EditorState, nodeType: NodeType) => boolean;
-export declare const parentBlockFormat: (state: EditorState) => string | null;
+declare const cleanTextBlockFormatting: (tr: Transaction, options?: CleanFormattingOptions) => void;
+declare const getBlockFormats: (state: EditorState) => Array<string>;
+declare const hasNode: (state: EditorState, nodeType: NodeType) => boolean;
+declare const parentBlockFormat: (state: EditorState) => string | null;
 /**
  * **Deprecated.** Use `parentBlockFormat` function instead.
  */
-export declare const activeNode: (state: EditorState) => {
+declare const activeNode: (state: EditorState) => {
     tag: string;
 };
+
+export { activeNode, blockNodes, changeTextBlock, cleanTextBlockFormatting, formatBlockElements, getBlockFormats, hasNode, parentBlockFormat };