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

package/dist/npm/find-replace.js

@@ -1,13 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.replaceAll = exports.replace = exports.findAll = exports.find = exports.findAt = void 0;
-var tslib_1 = require("tslib");
-var prosemirror_state_1 = require("prosemirror-state");
-var findAt = function (doc, searchOptions, start, end, exit) {
-    var result = [], exec, text, from, to, childText, nextSibling;
-    var nodes = [];
-    var matchCase = searchOptions.matchCase, matchWord = searchOptions.matchWord, useRegExp = searchOptions.useRegExp;
-    var searchText = searchOptions.text;
+'use strict';
+
+var prosemirrorState = require('prosemirror-state');
+
+const findAt = (doc, searchOptions, start, end, exit) => {
+    let result = [], exec, text, from, to, childText, nextSibling;
+    const nodes = [];
+    const { matchCase, matchWord, useRegExp } = searchOptions;
+    let searchText = searchOptions.text;
     if (useRegExp && (/^\\$/.test(searchText) || /[^\\]\\$/.test(searchText))) {
         // lookbehind doesn't work in Edge -> /((?<!\\)\\)$/.test(searchText)
         searchText = searchText.substring(0, searchText.length - 1);
@@ -15,19 +14,19 @@ var findAt = function (doc, searchOptions, start, end, exit) {
     if (!searchText) {
         return result;
     }
-    var flags = matchCase ? 'g' : 'gi';
-    var regExp = useRegExp ? new RegExp(searchText, flags) : createRegExp(searchText, flags);
-    doc.nodesBetween(start, end, function (node, pos) {
+    const flags = matchCase ? 'g' : 'gi';
+    const regExp = useRegExp ? new RegExp(searchText, flags) : createRegExp(searchText, flags);
+    doc.nodesBetween(start, end, (node, pos) => {
         if (exit(result)) {
             return false;
         }
         if (node.inlineContent && pos + node.content.size >= start) {
             nodes.length = 0;
-            node.nodesBetween(0, node.content.size, function (child, childPos, parent, i) {
+            node.nodesBetween(0, node.content.size, (child, childPos, parent, i) => {
                 if (exit(result)) {
                     return false;
                 }
-                var posToDoc = 1 + pos + childPos;
+                const posToDoc = 1 + pos + childPos;
                 if (child.isText && posToDoc + child.nodeSize >= start) {
                     childText = child.text || '';
                     nextSibling = parent.childCount - 1 >= i + 1 && parent.child(i + 1);
@@ -37,13 +36,13 @@ var findAt = function (doc, searchOptions, start, end, exit) {
                     if (nextSibling && nextSibling.isText) {
                         return;
                     }
-                    text = nodes.map(function (t) { return t.text; }).join('');
+                    text = nodes.map(t => t.text).join('');
                     exec = regExp.exec(text);
                     while (exec !== null) {
                         from = nodes[0].start + exec.index;
                         to = from + exec[0].length;
                         if (start <= from && end >= to && shouldMatchWord(exec, matchWord)) {
-                            result.push(prosemirror_state_1.TextSelection.create(doc, from, to));
+                            result.push(prosemirrorState.TextSelection.create(doc, from, to));
                         }
                         if (exit(result)) {
                             break;
@@ -59,69 +58,70 @@ var findAt = function (doc, searchOptions, start, end, exit) {
     });
     return result;
 };
-exports.findAt = findAt;
-var find = function (state, searchOptions) {
-    var backward = searchOptions.backward, matchCyclic = searchOptions.matchCyclic, options = tslib_1.__rest(searchOptions, ["backward", "matchCyclic"]);
-    var exit = backward ? function () { return false; } : function (r) { return r.length > 0; };
-    var doc = state.doc, selection = state.selection;
-    var result = [];
+const find = (state, searchOptions) => {
+    const { backward, matchCyclic, ...options } = searchOptions;
+    const exit = backward ? () => false : r => r.length > 0;
+    const { doc, selection } = state;
+    let result = [];
     if (backward) {
-        result = (0, exports.findAt)(doc, options, 0, selection.from, exit);
+        result = findAt(doc, options, 0, selection.from, exit);
         if (!result.length && matchCyclic) {
-            result = (0, exports.findAt)(doc, options, selection.from, doc.content.size, exit);
+            result = findAt(doc, options, selection.from, doc.content.size, exit);
         }
     }
     else {
-        result = (0, exports.findAt)(doc, options, selection.to, doc.content.size, exit);
+        result = findAt(doc, options, selection.to, doc.content.size, exit);
         if (!result.length && matchCyclic) {
-            result = (0, exports.findAt)(doc, options, 0, selection.to, exit);
+            result = findAt(doc, options, 0, selection.to, exit);
         }
     }
     return result.length ? result[result.length - 1] : null;
 };
-exports.find = find;
-var findAll = function (doc, searchOptions) {
-    return (0, exports.findAt)(doc, searchOptions, 0, doc.content.size, function () { return false; });
+const findAll = (doc, searchOptions) => {
+    return findAt(doc, searchOptions, 0, doc.content.size, () => false);
 };
-exports.findAll = findAll;
-var replace = function (selection, text, transaction) {
-    var from = selection.from, to = selection.to;
+const replace = (selection, text, transaction) => {
+    const { from, to } = selection;
     transaction.insertText(text, from, to)
-        .setSelection(prosemirror_state_1.TextSelection.create(transaction.doc, from, from + text.length));
+        .setSelection(prosemirrorState.TextSelection.create(transaction.doc, from, from + text.length));
     return transaction;
 };
-exports.replace = replace;
-var replaceAll = function (state, replaceText, searchOptions) {
-    var result = (0, exports.findAll)(state.doc, searchOptions);
+const replaceAll = (state, replaceText, searchOptions) => {
+    const result = findAll(state.doc, searchOptions);
     if (result.length === 0) {
         return null;
     }
-    var transaction = state.tr;
-    for (var i = result.length - 1; i >= 0; i--) {
+    const transaction = state.tr;
+    for (let i = result.length - 1; i >= 0; i--) {
         transaction.insertText(replaceText, result[i].from, result[i].to);
     }
     return transaction;
 };
-exports.replaceAll = replaceAll;
-var notLetter = /^[\s0-9~`!@#$%\^&*\(\)_\-=+\\|\[\]{};:'"\?/.,<>]?$/;
-var shouldMatchWord = function (exec, matchWord) {
+const notLetter = /^[\s0-9~`!@#$%\^&*\(\)_\-=+\\|\[\]{};:'"\?/.,<>]?$/;
+const shouldMatchWord = (exec, matchWord) => {
     if (!matchWord) {
         return true;
     }
     else if (matchWord === true) {
-        var text = exec.input;
-        var charBefore = text.charAt(exec.index - 1);
-        var charAfter = text.charAt(exec.index + exec[0].length);
+        const text = exec.input;
+        const charBefore = text.charAt(exec.index - 1);
+        const charAfter = text.charAt(exec.index + exec[0].length);
         return notLetter.test(charBefore) && notLetter.test(charAfter);
     }
     else {
         return matchWord(exec);
     }
 };
-var createRegExp = function (inputString, flags) {
-    var escaped = inputString
+const createRegExp = (inputString, flags) => {
+    const escaped = inputString
         .replace(/[|\\{}()[\]^$+*?.]/g, '\\$&')
         .replace(/-/g, '\\x2d')
         .replace(/\s/g, '\\s');
     return new RegExp(escaped, flags);
 };
+
+exports.find = find;
+exports.findAll = findAll;
+exports.findAt = findAt;
+exports.replace = replace;
+exports.replaceAll = replaceAll;

package/dist/npm/image.d.ts

@@ -1,8 +1,11 @@
-import { Command } from './types/command';
-export interface ImageData {
+import { Command } from './types/command.js';
+
+interface ImageData {
     src: string;
     alt?: string;
     width?: string;
     height?: string;
 }
-export declare const insertImage: (attrs: ImageData) => Command;
+declare const insertImage: (attrs: ImageData) => Command;
+
+export { type ImageData, insertImage };

package/dist/npm/image.js

@@ -1,11 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.insertImage = void 0;
-var utils_1 = require("./utils");
-var insertImage = function (attrs) { return function (state, dispatch) {
-    var image = state.schema.nodes.image;
-    var commandName = 'insertImage';
-    var newImage = image.createAndFill(attrs);
-    (0, utils_1.insertNode)(newImage)(state, function (tr) { return dispatch(tr.setMeta('commandName', commandName).setMeta('args', attrs)); });
-}; };
+'use strict';
+
+var utils = require('./utils.js');
+
+const insertImage = (attrs) => (state, dispatch) => {
+    const { image } = state.schema.nodes;
+    const commandName = 'insertImage';
+    const newImage = image.createAndFill(attrs);
+    utils.insertNode(newImage)(state, tr => dispatch(tr.setMeta('commandName', commandName).setMeta('args', attrs)));
+};
+
 exports.insertImage = insertImage;

package/dist/npm/indent.d.ts

@@ -1,16 +1,19 @@
 import { EditorState } from 'prosemirror-state';
 import { NodeType } from 'prosemirror-model';
-import { IndentRule, IndentationRules } from './config/indent-rules';
-import { Command } from './types/command';
+import { IndentRule, IndentationRules } from './config/indent-rules.js';
+import { Command } from './types/command.js';
+
 /**
  * Indenting block elements in the selection.
  *
  * @returns {boolean} - Returns true if any indentation is applied.
  */
-export declare const indentBlocks: (actions: Array<IndentRule>, command?: string, dir?: string) => Command;
-export declare const isIndented: (state: EditorState, rules: Array<IndentRule>, dir?: string) => boolean;
-export declare const canIndentAsListItem: (state: EditorState, nodeType: NodeType) => boolean;
-export declare const canOutdentAsListItem: (state: EditorState, rules: IndentationRules) => boolean;
-export declare const canBeIndented: (state: EditorState, rules: IndentationRules) => boolean;
-export declare const indent: Command;
-export declare const outdent: Command;
+declare const indentBlocks: (actions: Array<IndentRule>, command?: string, dir?: string) => Command;
+declare const isIndented: (state: EditorState, rules: Array<IndentRule>, dir?: string) => boolean;
+declare const canIndentAsListItem: (state: EditorState, nodeType: NodeType) => boolean;
+declare const canOutdentAsListItem: (state: EditorState, rules: IndentationRules) => boolean;
+declare const canBeIndented: (state: EditorState, rules: IndentationRules) => boolean;
+declare const indent: Command;
+declare const outdent: Command;
+
+export { canBeIndented, canIndentAsListItem, canOutdentAsListItem, indent, indentBlocks, isIndented, outdent };

package/dist/npm/indent.js

@@ -1,112 +1,113 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.outdent = exports.indent = exports.canBeIndented = exports.canOutdentAsListItem = exports.canIndentAsListItem = exports.isIndented = exports.indentBlocks = void 0;
-var prosemirror_schema_list_1 = require("prosemirror-schema-list");
-var indent_rules_1 = require("./config/indent-rules");
-var blockNode_1 = require("./blockNode");
-var utils_1 = require("./utils");
-var blockquote_1 = require("./blockquote");
+'use strict';
+
+var prosemirrorSchemaList = require('prosemirror-schema-list');
+var indentRules = require('./config/indent-rules.js');
+var blockNode = require('./blockNode.js');
+var utils = require('./utils.js');
+var blockquote = require('./blockquote.js');
+
 /**
  * Indenting block elements in the selection.
  *
  * @returns {boolean} - Returns true if any indentation is applied.
  */
-var indentBlocks = function (actions, command, dir) { return function (state, dispatch) {
-    var blocks = (0, blockNode_1.blockNodes)(state);
-    var tr = state.tr;
+const indentBlocks = (actions, command, dir) => (state, dispatch) => {
+    const blocks = blockNode.blockNodes(state);
+    const tr = state.tr;
     tr.setMeta('commandName', command);
-    blocks.forEach(function (node) {
+    blocks.forEach(node => {
         if (node.type.isTextblock) {
-            var newAttrs = void 0;
-            var action = actions.find(function (a) { return a.node === node.type.name; });
+            let newAttrs;
+            const action = actions.find(a => a.node === node.type.name);
             if (action) {
-                var style = dir === 'rtl' ? action.rtlStyle : action.style;
-                var newStyle = {
+                const style = dir === 'rtl' ? action.rtlStyle : action.style;
+                const newStyle = {
                     name: style,
-                    value: action.step > 0 ? "".concat(action.step).concat(action.unit) : ''
+                    value: action.step > 0 ? `${action.step}${action.unit}` : ''
                 };
                 if (node.attrs.style) {
-                    var re = new RegExp("".concat(style, ":\\s?(\\d+)").concat(action.unit), 'i');
-                    var match = node.attrs.style.match(re);
+                    const re = new RegExp(`${style}:\\s?(\\d+)${action.unit}`, 'i');
+                    const match = node.attrs.style.match(re);
                     if (match) {
-                        var newMargin = parseFloat(match[1]) + action.step;
+                        let newMargin = parseFloat(match[1]) + action.step;
                         newMargin = newMargin <= 0 ? '' : newMargin;
-                        newStyle.value = "".concat(newMargin).concat(newMargin ? action.unit : '');
+                        newStyle.value = `${newMargin}${newMargin ? action.unit : ''}`;
                     }
                 }
-                newAttrs = (0, blockNode_1.addStyles)(node, [newStyle]);
+                newAttrs = blockNode.addStyles(node, [newStyle]);
             }
             if (newAttrs) {
-                (0, blockNode_1.changeTextBlock)(tr, node, node.type, newAttrs);
+                blockNode.changeTextBlock(tr, node, node.type, newAttrs);
             }
         }
     });
-    var result = tr.docChanged;
+    const result = tr.docChanged;
     if (result) {
         dispatch(tr.scrollIntoView());
     }
     return result;
-}; };
-exports.indentBlocks = indentBlocks;
-var isIndented = function (state, rules, dir) {
-    var blocks = (0, blockNode_1.blockNodes)(state);
-    var result = false;
-    blocks.forEach(function (node) {
+};
+const isIndented = (state, rules, dir) => {
+    const blocks = blockNode.blockNodes(state);
+    let result = false;
+    blocks.forEach(node => {
         if (!result && node.type.isTextblock && node.attrs.style) {
-            var action = rules.find(function (a) { return a.node === node.type.name; });
+            const action = rules.find(a => a.node === node.type.name);
             if (action) {
-                var style = dir === 'rtl' ? action.rtlStyle : action.style;
-                var reIndent = new RegExp("".concat(style, ":\\s?\\d+").concat(action.unit), 'i');
+                const style = dir === 'rtl' ? action.rtlStyle : action.style;
+                const reIndent = new RegExp(`${style}:\\s?\\d+${action.unit}`, 'i');
                 result = reIndent.test(node.attrs.style);
             }
         }
     });
     return result;
 };
-exports.isIndented = isIndented;
-var canIndentAsListItem = function (state, nodeType) {
-    return (0, prosemirror_schema_list_1.sinkListItem)(nodeType)(state);
+const canIndentAsListItem = (state, nodeType) => {
+    return prosemirrorSchemaList.sinkListItem(nodeType)(state);
 };
-exports.canIndentAsListItem = canIndentAsListItem;
-var canOutdentAsListItem = function (state, rules) {
-    var listItem = state.schema.nodes[rules.listsTypes.listItem];
-    var orderedList = state.schema.nodes[rules.listsTypes.orderedList];
-    var bulletList = state.schema.nodes[rules.listsTypes.bulletList];
-    var isNestedInOL = !!(0, utils_1.findNthParentNodeOfType)(orderedList, 2)(state.selection);
-    var isNestedInUL = !!(0, utils_1.findNthParentNodeOfType)(bulletList, 2)(state.selection);
-    return (isNestedInOL || isNestedInUL) && (0, prosemirror_schema_list_1.liftListItem)(listItem)(state);
+const canOutdentAsListItem = (state, rules) => {
+    const listItem = state.schema.nodes[rules.listsTypes.listItem];
+    const orderedList = state.schema.nodes[rules.listsTypes.orderedList];
+    const bulletList = state.schema.nodes[rules.listsTypes.bulletList];
+    const isNestedInOL = !!utils.findNthParentNodeOfType(orderedList, 2)(state.selection);
+    const isNestedInUL = !!utils.findNthParentNodeOfType(bulletList, 2)(state.selection);
+    return (isNestedInOL || isNestedInUL) && prosemirrorSchemaList.liftListItem(listItem)(state);
 };
-exports.canOutdentAsListItem = canOutdentAsListItem;
-var canBeIndented = function (state, rules) {
-    var nodes = state.schema.nodes;
-    var listItem = nodes[indent_rules_1.indentRules.listsTypes.listItem];
-    return (((0, exports.isIndented)(state, rules.nodes) || indent_rules_1.indentRules.nodes.some(function (rule) { return nodes[rule.node] && (0, blockNode_1.hasNode)(state, nodes[rule.node]); })) &&
-        !(0, blockNode_1.hasNode)(state, listItem));
+const canBeIndented = (state, rules) => {
+    const nodes = state.schema.nodes;
+    const listItem = nodes[indentRules.indentRules.listsTypes.listItem];
+    return ((isIndented(state, rules.nodes) || indentRules.indentRules.nodes.some(rule => nodes[rule.node] && blockNode.hasNode(state, nodes[rule.node]))) &&
+        !blockNode.hasNode(state, listItem));
 };
-exports.canBeIndented = canBeIndented;
-var indent = function (state, dispatch) {
-    var listItem = state.schema.nodes[indent_rules_1.indentRules.listsTypes.listItem];
-    var isIndentableBlock = (0, exports.canBeIndented)(state, indent_rules_1.indentRules);
-    if ((0, exports.canIndentAsListItem)(state, listItem)) {
-        (0, prosemirror_schema_list_1.sinkListItem)(listItem)(state, dispatch);
+const indent = (state, dispatch) => {
+    const listItem = state.schema.nodes[indentRules.indentRules.listsTypes.listItem];
+    const isIndentableBlock = canBeIndented(state, indentRules.indentRules);
+    if (canIndentAsListItem(state, listItem)) {
+        prosemirrorSchemaList.sinkListItem(listItem)(state, dispatch);
     }
     else if (isIndentableBlock) {
-        (0, exports.indentBlocks)(indent_rules_1.indentRules.nodes)(state, dispatch);
+        indentBlocks(indentRules.indentRules.nodes)(state, dispatch);
     }
 };
-exports.indent = indent;
-var outdent = function (state, dispatch) {
-    var nodes = state.schema.nodes;
-    var listItem = nodes[indent_rules_1.outdentRules.listsTypes.listItem];
-    var isIndentableBlock = (0, exports.canBeIndented)(state, indent_rules_1.outdentRules);
-    if ((0, blockNode_1.hasNode)(state, nodes.blockquote)) {
-        (0, blockquote_1.liftBlockquote)(state, dispatch);
+const outdent = (state, dispatch) => {
+    const nodes = state.schema.nodes;
+    const listItem = nodes[indentRules.outdentRules.listsTypes.listItem];
+    const isIndentableBlock = canBeIndented(state, indentRules.outdentRules);
+    if (blockNode.hasNode(state, nodes.blockquote)) {
+        blockquote.liftBlockquote(state, dispatch);
     }
-    else if ((0, exports.canOutdentAsListItem)(state, indent_rules_1.outdentRules)) {
-        (0, prosemirror_schema_list_1.liftListItem)(listItem)(state, dispatch);
+    else if (canOutdentAsListItem(state, indentRules.outdentRules)) {
+        prosemirrorSchemaList.liftListItem(listItem)(state, dispatch);
     }
     else if (isIndentableBlock) {
-        (0, exports.indentBlocks)(indent_rules_1.outdentRules.nodes)(state, dispatch);
+        indentBlocks(indentRules.outdentRules.nodes)(state, dispatch);
     }
 };
+
+exports.canBeIndented = canBeIndented;
+exports.canIndentAsListItem = canIndentAsListItem;
+exports.canOutdentAsListItem = canOutdentAsListItem;
+exports.indent = indent;
+exports.indentBlocks = indentBlocks;
+exports.isIndented = isIndented;
 exports.outdent = outdent;

package/dist/npm/inline-style.d.ts

@@ -1,20 +1,23 @@
 import { EditorState, Transaction } from 'prosemirror-state';
-import { InlineFormatOptions } from './config/commands';
+import { InlineFormatOptions } from './config/commands.js';
+
 /**
  * Used by FontSize and FontName tools for getting their state.
  */
-export declare const getInlineStyles: (state: EditorState, style: {
+declare const getInlineStyles: (state: EditorState, style: {
     name: string;
     value: RegExp;
 }) => Array<string>;
 /**
  * Used by bold, italic, ... and link commands.
  */
-export declare const toggleInlineFormat: (options: InlineFormatOptions, tr?: Transaction, markAttrs?: any) => (state: any, dispatch: any) => boolean;
+declare const toggleInlineFormat: (options: InlineFormatOptions, tr?: Transaction, markAttrs?: any) => (state: any, dispatch: any) => boolean;
 /**
  * Used by FontSize, FontName, Color and BackColor commands.
  */
-export declare const applyInlineStyle: (options: {
+declare const applyInlineStyle: (options: {
     style: string;
     value: string;
 }, command?: string) => (state: any, dispatch: any) => boolean;
+
+export { applyInlineStyle, getInlineStyles, toggleInlineFormat };