@progress/kendo-editor-common 1.12.2-develop.4 → 1.12.2-develop.6

package/dist/es2015/inline-style.js

@@ -1,177 +0,0 @@
-import { RemoveMarkStep, AddMarkStep } from 'prosemirror-transform';
-import { TextSelection } from 'prosemirror-state';
-import { changeStylesString, shallowEqual } from './utils.js';
-import { markApplies, selectionMarks, styleValue, hasMark, removeMarks, toggleMark } from './mark.js';
-
-const changeStyleFromMark = (marks, toChange) => {
-    const styleMark = marks.find(m => m.type.name === 'style');
-    const elementStyle = styleMark && styleMark.attrs.style;
-    return changeStylesString(elementStyle, toChange);
-};
-const changeStyleMark = (tr, from, to, attrs, markType) => {
-    const mark = markType.create({ style: attrs.style });
-    let removed = [], added = [], removing = null, adding = null;
-    tr.doc.nodesBetween(from, to, (node, pos, parent) => {
-        if (!node.isInline) {
-            return;
-        }
-        const marks = node.marks;
-        if (!mark.isInSet(marks) && parent.type.allowsMarkType(mark.type)) {
-            const start = Math.max(pos, from), end = Math.min(pos + node.nodeSize, to);
-            const newStyle = changeStyleFromMark(marks, attrs);
-            if (newStyle.changed || attrs.newValue) {
-                const style = newStyle.changed ?
-                    { style: newStyle.style || null } : { style: `${[attrs.style]}: ${attrs.newValue};` };
-                const currentMark = markType.isInSet(marks) ? marks.find(m => m.type.name === 'style') : null;
-                const newMarkAttrs = currentMark ? Object.assign(Object.assign({}, currentMark.attrs), style) : style;
-                const newStyleMark = markType.create(newMarkAttrs);
-                const newSet = newStyleMark.addToSet(marks);
-                for (let i = 0; i < marks.length; i++) {
-                    if (!marks[i].isInSet(newSet)) {
-                        if (removing && removing.to === start && removing.mark.eq(marks[i])) {
-                            removing.to = end;
-                        }
-                        else {
-                            removing = new RemoveMarkStep(start, end, marks[i]);
-                            removed.push(removing);
-                        }
-                    }
-                }
-                const previousAdded = adding && adding.to === start;
-                const sameAdding = previousAdded && newStyleMark.attrs.style === adding.mark.attrs.style;
-                if (previousAdded && sameAdding) {
-                    adding.to = end;
-                }
-                else if (Object.keys(newMarkAttrs).some(attrName => newMarkAttrs[attrName] !== null)) {
-                    adding = new AddMarkStep(start, end, newStyleMark);
-                    added.push(adding);
-                }
-            }
-        }
-    });
-    removed.forEach(s => tr.step(s));
-    added.forEach(s => tr.step(s));
-    return removed.length + added.length > 0;
-};
-/**
- * Used by FontSize and FontName tools for getting their state.
- */
-const getInlineStyles = (state, style) => {
-    const styleMark = state.schema.marks.style;
-    const marks = styleMark ? selectionMarks(state, styleMark) : [];
-    return marks.map(mark => styleValue(mark, style)).filter(m => m !== null);
-};
-const changeStyle = (markType, attrs) => {
-    return function (state, dispatch, tr) {
-        const { empty, ranges } = state.selection;
-        const $cursor = state.selection instanceof TextSelection && state.selection.$cursor;
-        if ((empty && !$cursor) || !markApplies(state.doc, ranges, markType)) {
-            return false;
-        }
-        let result = false;
-        if (dispatch) {
-            const transaction = tr || state.tr;
-            if ($cursor) {
-                const currentMarks = state.storedMarks || $cursor.marks();
-                if (markType.isInSet(currentMarks)) {
-                    const newStyle = changeStyleFromMark(currentMarks, attrs);
-                    const styleMark = currentMarks.find(m => m.type.name === 'style');
-                    const newAttrs = Object.assign(Object.assign({}, (styleMark ? styleMark.attrs : {})), { style: newStyle.style || null });
-                    if (shallowEqual(styleMark.attrs, newAttrs)) {
-                        return false;
-                    }
-                    dispatch(transaction.removeStoredMark(markType));
-                    if (Object.keys(newAttrs).some(attrName => newAttrs[attrName] !== null)) {
-                        dispatch(transaction.addStoredMark(markType.create(newAttrs)));
-                    }
-                    result = true;
-                }
-            }
-            else {
-                for (let i = 0; i < ranges.length; i++) {
-                    const { $from, $to } = ranges[i];
-                    result = changeStyleMark(transaction, $from.pos, $to.pos, attrs, markType) || result;
-                }
-                if (result) {
-                    transaction.scrollIntoView();
-                    dispatch(transaction);
-                }
-            }
-        }
-        return result;
-    };
-};
-/**
- * Used by bold, italic, ... and link commands.
- */
-const toggleInlineFormat = (options, tr, markAttrs) => (state, dispatch) => {
-    const marks = state.schema.marks;
-    const { altStyle, altMarks = [], mark } = options;
-    const transaction = tr || state.tr;
-    let styleRemoved = false;
-    let dispatched = false;
-    const markDispatched = () => dispatched = true;
-    if (altStyle && marks.style) {
-        const cmd = changeStyle(marks.style, { style: altStyle.name, value: altStyle.value });
-        styleRemoved = cmd(state, markDispatched, transaction);
-    }
-    const allMarks = [mark, ...altMarks].filter(m => marks[m]);
-    const toRemove = allMarks.map(m => hasMark(state, { mark: m }) && marks[m]).filter(m => m);
-    if (toRemove.length) {
-        removeMarks(toRemove, state, markDispatched, transaction);
-    }
-    else {
-        if (!styleRemoved) {
-            toggleMark(marks[mark], markAttrs, transaction)(state, markDispatched);
-        }
-    }
-    if (dispatched) {
-        dispatch(transaction);
-    }
-    return dispatched;
-};
-/**
- * Used by FontSize, FontName, Color and BackColor commands.
- */
-const applyInlineStyle = (options, command) => (state, dispatch) => {
-    const marks = state.schema.marks;
-    const markType = marks.style;
-    const attrs = {
-        style: options.style, value: /^.+$/, newValue: options.value
-    };
-    const tr = state.tr;
-    if (command) {
-        tr.setMeta('commandName', command);
-    }
-    tr.setMeta('args', options);
-    const { empty, $cursor, ranges } = state.selection;
-    if ((empty && !$cursor) || !markType || !markApplies(state.doc, ranges, markType)) {
-        return false;
-    }
-    // Empty selection
-    if ($cursor) {
-        const marksFromSelection = state.storedMarks || $cursor.marks();
-        const currentMark = markType.isInSet(marksFromSelection) ? marksFromSelection.find(m => m.type.name === 'style') : null;
-        const newStyles = { style: null };
-        if (currentMark && currentMark.attrs.style) {
-            const resultStyles = changeStylesString(currentMark.attrs.style, attrs);
-            if (resultStyles.changed && resultStyles.style) {
-                newStyles.style = resultStyles.style;
-            }
-        }
-        else if (attrs.newValue) {
-            newStyles.style = `${[attrs.style]}: ${attrs.newValue};`;
-        }
-        const newMarkAttrs = currentMark ? Object.assign(Object.assign({}, currentMark.attrs), newStyles) : newStyles;
-        if (Object.keys(newMarkAttrs).some(attrName => newMarkAttrs[attrName] !== null)) {
-            dispatch(tr.addStoredMark(markType.create(newMarkAttrs)));
-        }
-        else {
-            dispatch(tr.removeStoredMark(markType));
-        }
-        return true;
-    }
-    return changeStyle(markType, attrs)(state, dispatch, tr);
-};
-
-export { applyInlineStyle, getInlineStyles, toggleInlineFormat };

package/dist/es2015/link.js

@@ -1,105 +0,0 @@
-import { toggleInlineFormat } from './inline-style.js';
-import { hasMark, toggleMark, removeMark, selectionMarks } from './mark.js';
-import { EditorState } from 'prosemirror-state';
-
-const modifyLink = (options, tr) => (state, dispatch) => {
-    const { $cursor, from, to } = state.selection;
-    const markType = state.schema.marks[options.mark];
-    if (!$cursor) {
-        tr.doc.nodesBetween(from, to, (node, pos) => {
-            if (node.isInline && markType.isInSet(node.marks)) {
-                tr.removeMark(pos, pos + node.nodeSize, markType);
-                tr.addMark(pos, pos + node.nodeSize, markType.create(options.attrs));
-                dispatch(tr);
-            }
-        });
-    }
-    else {
-        const parentNode = $cursor.parent;
-        const cursorNodeIndex = $cursor.index();
-        const mark = parentNode.child(cursorNodeIndex).marks.find(m => m.type === markType);
-        const childCount = parentNode.childCount;
-        let linkStart = $cursor.pos - $cursor.textOffset, linkSize = parentNode.child(cursorNodeIndex).nodeSize, index, nodeSize;
-        index = cursorNodeIndex - 1;
-        while (index >= 0 && mark.isInSet(parentNode.child(index).marks)) {
-            nodeSize = parentNode.child(index).nodeSize;
-            linkSize += nodeSize;
-            linkStart -= nodeSize;
-            index -= 1;
-        }
-        index = cursorNodeIndex + 1;
-        while (index < childCount && mark.isInSet(parentNode.child(index).marks)) {
-            linkSize += parentNode.child(index).nodeSize;
-            index += 1;
-        }
-        tr.removeMark(linkStart, linkStart + linkSize, markType);
-        tr.addMark(linkStart, linkStart + linkSize, markType.create(options.attrs));
-        dispatch(tr);
-    }
-};
-const removeLink = (options, tr) => (state, dispatch) => {
-    const { $cursor } = state.selection;
-    if (!$cursor) {
-        toggleInlineFormat(options, tr)(state, dispatch);
-    }
-    else {
-        const parentNode = $cursor.parent;
-        const cursorNodeIndex = $cursor.index();
-        const toolMark = state.schema.marks[options.mark];
-        const mark = parentNode.child(cursorNodeIndex).marks.find(m => m.type === toolMark);
-        const childCount = parentNode.childCount;
-        let linkStart = $cursor.pos - $cursor.textOffset, linkSize = parentNode.child(cursorNodeIndex).nodeSize, index, nodeSize;
-        index = cursorNodeIndex - 1;
-        while (index >= 0 && mark.isInSet(parentNode.child(index).marks)) {
-            nodeSize = parentNode.child(index).nodeSize;
-            linkSize += nodeSize;
-            linkStart -= nodeSize;
-            index -= 1;
-        }
-        index = cursorNodeIndex + 1;
-        while (index < childCount && mark.isInSet(parentNode.child(index).marks)) {
-            linkSize += parentNode.child(index).nodeSize;
-            index += 1;
-        }
-        dispatch(removeMark(tr || state.tr, linkStart, linkStart + linkSize, mark));
-    }
-};
-/**
- * Returns a mark which wraps the selection.
- */
-const getParentMark = (state, markType) => {
-    const marks = selectionMarks(state, markType);
-    return marks.length === 1 && marks[0] ? marks[0] : null;
-};
-const applyLink = ({ mark, attrs }, commandName = 'link') => (state, dispatch) => {
-    const marks = state.schema.marks;
-    const tr = state.tr;
-    if (commandName) {
-        tr.setMeta('commandName', commandName);
-        tr.setMeta('args', attrs);
-    }
-    let dispatched = false;
-    const markDispatched = () => dispatched = true;
-    if (getParentMark(state, marks[mark])) {
-        modifyLink({ mark, attrs }, tr)(state, markDispatched);
-    }
-    else {
-        let nextState = state;
-        if (hasMark(state, { mark })) {
-            removeLink({ mark}, tr)(state, markDispatched);
-            nextState = EditorState.create({ doc: tr.doc, selection: tr.selection });
-        }
-        if (dispatched) {
-            toggleMark(marks[mark], attrs, tr)(nextState, markDispatched);
-        }
-        else {
-            toggleInlineFormat({ mark: mark }, tr, attrs)(nextState, markDispatched);
-        }
-    }
-    if (dispatched) {
-        dispatch(tr);
-    }
-    return dispatched;
-};
-
-export { applyLink, removeLink };

package/dist/es2015/listConvert.js

@@ -1,184 +0,0 @@
-import { htmlToFragment, fragmentToHtml } from './source.js';
-
-const msoListRegExp = /style=['"]?[^'"]*?mso-list:\s*[a-zA-Z]+(\d+)\s[a-zA-Z]+(\d+)\s(\w+)/gi;
-const extractListLevels = (html) => {
-    html = html.replace(msoListRegExp, (match, list, level) => {
-        return `datalist="${list}" datalevel="${level}" ${match}`;
-    });
-    return html;
-};
-const isPartOfListItem = (element) => {
-    return /^MsoListParagraph/.test(element.className);
-};
-const innerText = (node) => {
-    return node.textContent;
-};
-const createList = (type, styleType) => {
-    const list = document.createElement(type);
-    list.style.listStyleType = styleType;
-    return list;
-};
-const guessUnorderedListStyle = (symbol) => {
-    if (/^[\u2022\u00b7\u00FC\u00D8\u002dv-]/.test(symbol)) {
-        return null; // return "disc"; //default CSS value
-    }
-    else if (/^o/.test(symbol)) {
-        return 'circle';
-    }
-    else {
-        return 'square';
-    }
-};
-const guessOrderedListStyle = (symbol) => {
-    let type = null;
-    if (!/^\d/.test(symbol)) {
-        type = (/^[a-z]/.test(symbol) ? 'lower-' : 'upper-') +
-            (/^[ivxlcdm]/i.test(symbol) ? 'roman' : 'alpha');
-    }
-    return type;
-};
-const mapListsCandidates = (nodes, groups) => {
-    let group = [];
-    Array.from(nodes).forEach(node => {
-        if (node.nodeType !== Node.ELEMENT_NODE) {
-            return;
-        }
-        const element = node;
-        if (element.getAttribute('datalist')) {
-            group.push(node);
-            groups.add(group);
-        }
-        else if (isPartOfListItem(element) && group.length) {
-            group.push(node);
-        }
-        else {
-            group = [];
-            if (element.nodeName === 'DIV') {
-                mapListsCandidates(element.children, groups);
-            }
-            else if (element.nodeName === 'TABLE') {
-                Array.from(element.querySelectorAll('td,th')).forEach(cell => {
-                    mapListsCandidates(cell.children, groups);
-                });
-            }
-        }
-    });
-};
-const listTypes = (p) => {
-    const html = p.textContent;
-    const trimStartText = (t) => {
-        return t.replace(/^(?: |[\u00a0\n\r\s])+/, '');
-    };
-    if ((/^[\u2022\u00b7\u00a7\u00d8oØüvn][\u00a0 ]+/.test(html))) {
-        return {
-            tag: 'ul',
-            style: guessUnorderedListStyle(trimStartText(innerText(p)))
-        };
-    }
-    if (/^\s*\w+[\.\)][\u00a0 ]{2,}/.test(html)) {
-        return {
-            tag: 'ol',
-            style: guessOrderedListStyle(trimStartText(innerText(p)))
-        };
-    }
-};
-const convertToLi = (p) => {
-    let content, name = p.nodeName.toLowerCase();
-    if (p.firstChild && p.firstChild.nodeType === Node.COMMENT_NODE) {
-        p.removeChild(p.firstChild);
-    }
-    if (p.childNodes.length === 1) {
-        content = p.firstChild.nodeType === Node.TEXT_NODE ?
-            innerText(p) : p.firstChild.innerHTML.replace(/^\w+[\.\)]( )+ /, '');
-    }
-    else {
-        p.removeChild(p.firstChild);
-        // check for Roman numerals
-        if (p.firstChild.nodeType === 3) {
-            if (/^[ivxlcdm]+\.$/i.test(p.firstChild.nodeValue)) {
-                p.removeChild(p.firstChild);
-            }
-        }
-        if (/^( |\s)+$/i.test(p.firstChild.innerHTML)) {
-            p.removeChild(p.firstChild);
-        }
-        if (name !== 'p') {
-            content = '<' + name + '>' + p.innerHTML + '</' + name + '>';
-        }
-        else {
-            content = p.innerHTML;
-        }
-    }
-    p.parentNode.removeChild(p);
-    const li = document.createElement('li');
-    li.appendChild(htmlToFragment(content));
-    return li;
-};
-const toList = (blockNodes) => {
-    let lastMargin = -1, levels = {}, li, rootMargin, rootIndex, lastRootLi, isLastRootLi, rootList, items, i, p, type, margin, list, listData;
-    for (i = 0; i < blockNodes.length; i++) {
-        p = blockNodes[i];
-        listData = {
-            datalist: p.getAttribute('datalist'),
-            datalevel: p.getAttribute('datalevel')
-        };
-        const listIndex = listData.datalist;
-        const listType = listTypes(p);
-        type = listType && listType.tag;
-        if (!type) {
-            if (li && (!isLastRootLi || isPartOfListItem(p))) {
-                if (p.style.marginLeft) {
-                    p.style.marginLeft = '';
-                }
-                if (p.style.marginLeft) {
-                    // tests runner/framework fails to delete marginLeft
-                    p.style.margin = '';
-                }
-                li.appendChild(p);
-            }
-            continue;
-        }
-        margin = listData.datalevel || parseFloat(p.style.marginLeft || 0);
-        if (!listData.datalevel && !p.style.marginLeft) {
-            continue;
-        }
-        const levelType = type + listIndex;
-        if (!levels[margin]) {
-            levels[margin] = {};
-        }
-        if (!rootMargin || rootMargin < 0) {
-            rootMargin = margin;
-            rootIndex = listIndex;
-            items = blockNodes.filter(e => e.getAttribute('datalist') === String(rootIndex));
-            lastRootLi = items[items.length - 1];
-            rootList = createList(type, listType && listType.style);
-            p.parentNode.insertBefore(rootList, p);
-            lastMargin = margin;
-            levels[margin][levelType] = rootList;
-        }
-        isLastRootLi = lastRootLi === p;
-        list = levels[margin][levelType];
-        if (margin > lastMargin || !list) {
-            list = createList(type, listType && listType.style);
-            levels[margin][levelType] = list;
-            li.appendChild(list);
-        }
-        li = convertToLi(p);
-        list.appendChild(li);
-        if (isLastRootLi) {
-            rootMargin = lastMargin = -1;
-        }
-        else {
-            lastMargin = margin;
-        }
-    }
-};
-const convertMsLists = (html) => {
-    const container = htmlToFragment(extractListLevels(html));
-    const groups = new Set();
-    mapListsCandidates(container.children, groups);
-    groups.forEach(listsCandidates => toList(listsCandidates));
-    return fragmentToHtml(container);
-};
-
-export { convertMsLists };