@contentful/field-editor-markdown 1.2.1 → 1.3.0

package/dist/cjs/utils/isValidUrl.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    urlRegex: function() {
+        return urlRegex;
+    },
+    isValidUrl: function() {
+        return isValidUrl;
+    }
+});
+const urlRegex = /^(ftp|http|https):\/\/(\w+:{0,1}\w*@)?(\S+)(:[0-9]+)?(\/|\/([\w#!:.?+=&%@!\-/]))?$/;
+function isValidUrl(value) {
+    return urlRegex.test(value);
+}

package/dist/cjs/utils/linkOrganizer.js

@@ -0,0 +1,187 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    findInline: function() {
+        return findInline;
+    },
+    findRefs: function() {
+        return findRefs;
+    },
+    findLabels: function() {
+        return findLabels;
+    },
+    convertInlineToRef: function() {
+        return convertInlineToRef;
+    },
+    rewriteRefs: function() {
+        return rewriteRefs;
+    },
+    findMaxLabelId: function() {
+        return findMaxLabelId;
+    }
+});
+const _extend = _interop_require_default(require("lodash/extend"));
+const _isObject = _interop_require_default(require("lodash/isObject"));
+const _isString = _interop_require_default(require("lodash/isString"));
+const _max = _interop_require_default(require("lodash/max"));
+const _isFinite = _interop_require_default(require("lodash/isFinite"));
+const _forEach = _interop_require_default(require("lodash/forEach"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function extractTitle(title) {
+    title = title || '';
+    title = title.replace(/^ *('|"|\()*/, '');
+    title = title.replace(/('|"|\))* *$/, '');
+    return title;
+}
+function head(text) {
+    return text.split(' ').shift();
+}
+function tail(text) {
+    const segments = text.split(' ');
+    segments.shift();
+    return segments.join(' ');
+}
+const PROCESSORS = {
+    inline: function(match) {
+        return {
+            match: match[0],
+            text: match[1],
+            href: head(match[2]),
+            title: extractTitle(tail(match[2]))
+        };
+    },
+    ref: function(match) {
+        return {
+            match: match[0],
+            text: match[1],
+            id: match[2]
+        };
+    },
+    label: function(match) {
+        return {
+            match: match[0],
+            id: match[1],
+            href: head(match[2]),
+            title: extractTitle(tail(match[2]))
+        };
+    }
+};
+const REGEXS = {
+    inline: /\[([^\r\n[\]]+)]\(([^\r\n)]+)\)/,
+    ref: /\[([^\r\n[\]]+)] ?\[([^\r\n[\]]+)]/,
+    label: /^ {0,3}\[([^\r\n[\]]+)]:\s+(.+)$/
+};
+const findInline = makeFinder('inline');
+const findRefs = makeFinder('ref');
+const findLabels = makeFinder('label');
+function convertInlineToRef(text) {
+    let id = findMaxLabelId(text);
+    (0, _forEach.default)(findInline(text), (inline)=>{
+        id += 1;
+        text = text.replace(inline.match, buildRef(inline, id));
+        text += '\n' + buildLabel(inline, id);
+    });
+    return text;
+}
+function mergeLabels(text) {
+    const byHref = {};
+    const byOldId = {};
+    (0, _forEach.default)(findLabels(text), (label)=>{
+        const alreadyAdded = byHref[label.href];
+        const current = (0, _extend.default)({}, label);
+        if (!alreadyAdded) {
+            byHref[current.href] = current;
+        } else if (hasTitle(current) && !hasTitle(alreadyAdded)) {
+            alreadyAdded.title = current.title;
+        }
+        byOldId[current.id] = alreadyAdded || current;
+    });
+    return {
+        byHref: byHref,
+        byOldId: byOldId
+    };
+}
+function rewriteRefs(text) {
+    const merged = mergeLabels(text);
+    const hrefToRefId = {};
+    const labels = [];
+    const rewrites = [];
+    let i = 1;
+    (0, _forEach.default)(findRefs(text), (ref)=>{
+        const oldLabel = merged.byOldId[ref.id];
+        if (!oldLabel) {
+            return;
+        }
+        const href = oldLabel.href;
+        let newRefId = hrefToRefId[href];
+        if (!newRefId) {
+            hrefToRefId[href] = newRefId = i;
+            i += 1;
+            labels.push((0, _extend.default)({
+                newId: newRefId
+            }, oldLabel));
+        }
+        rewrites.push((0, _extend.default)({
+            newId: newRefId
+        }, ref));
+    });
+    (0, _forEach.default)(findLabels(text), (label)=>{
+        text = text.replace(label.match, '');
+    });
+    text = text.replace(/[\r\n\s]*$/, '');
+    text += '\n\n';
+    (0, _forEach.default)(rewrites, (ref)=>{
+        text = text.replace(ref.match, buildRef(ref, ref.newId));
+    });
+    (0, _forEach.default)(labels, (label)=>{
+        text += '\n' + buildLabel(label, label.newId);
+    });
+    return text;
+}
+function makeFinder(type) {
+    return (text)=>findAll(text, type).map(PROCESSORS[type]);
+}
+function findMaxLabelId(textOrLabels) {
+    if ((0, _isString.default)(textOrLabels)) {
+        textOrLabels = findLabels(textOrLabels);
+    }
+    const ids = textOrLabels.map((x)=>x.id).map((x)=>parseInt(x, 10)).filter((x)=>(0, _isFinite.default)(x) && x > 0);
+    return ids.length > 0 ? (0, _max.default)(ids) || 0 : 0;
+}
+function findAll(text, type) {
+    const flags = 'g' + (type === 'label' ? 'm' : '');
+    const matches = [];
+    const re = new RegExp(REGEXS[type].source, flags);
+    let found = re.exec(text);
+    while(found){
+        matches.push(found);
+        re.lastIndex = found.index + found[0].length;
+        found = re.exec(text);
+    }
+    return matches;
+}
+function hasTitle(link) {
+    return (0, _isObject.default)(link) && (0, _isString.default)(link.title) && link.title.length > 0;
+}
+function buildLabel(link, id) {
+    let markup = '[' + id + ']: ' + link.href;
+    if (hasTitle(link)) {
+        markup += ' "' + link.title + '"';
+    }
+    return markup;
+}
+function buildRef(link, id) {
+    return '[' + link.text + '][' + id + ']';
+}

package/dist/cjs/utils/linkOrganizer.spec.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _linkOrganizer = _interop_require_wildcard(require("./linkOrganizer"));
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+describe('Link organizer', ()=>{
+    describe('Inline link finder', ()=>{
+        it('Finds all inline links in text', ()=>{
+            const subject = 'test [link](http://url.com) test [link2](http://url2.com) test [link3](http://url.com)';
+            const found = _linkOrganizer.findInline(subject);
+            expect(found).toHaveLength(3);
+            expect(found[0].match).toBe('[link](http://url.com)');
+            expect(found[0].text).toBe('link');
+            expect(found[0].href).toBe('http://url.com');
+            expect(found[0].title).toBe('');
+        });
+        it('Finds and standardizes title', ()=>{
+            const subject = 'test [x](http://url.com   "title!") [y](http://xyz.com title 2   )';
+            const found = _linkOrganizer.findInline(subject);
+            expect(found).toHaveLength(2);
+            expect(found[0].title).toBe('title!');
+            expect(found[1].title).toBe('title 2');
+        });
+    });
+    describe('Reference finder', ()=>{
+        it('Finds all references in text', ()=>{
+            const subject = 'test [x][1] test [y][2] [with space separator] [3]';
+            const found = _linkOrganizer.findRefs(subject);
+            expect(found).toHaveLength(3);
+            expect(found[0].match).toBe('[x][1]');
+            expect(found[2].match).toBe('[with space separator] [3]');
+            expect(found[1].text).toBe('y');
+            expect(found[1].id).toBe('2');
+        });
+    });
+    describe('Label finder', ()=>{
+        const subject = [
+            '[1]:  http://test.com',
+            '[2]: http://url.com',
+            '[string]: http://url.com',
+            '[4]: http://test.com  "Hello world"'
+        ].join('\n');
+        it('Finds all labels', ()=>{
+            const found = _linkOrganizer.findLabels(subject);
+            expect(found).toHaveLength(4);
+            expect(found[0].id).toBe('1');
+            expect(found[2].id).toBe('string');
+            expect(found[0].href).toBe('http://test.com');
+            expect(found[3].href).toBe('http://test.com');
+            expect(found[1].title).toBe('');
+            expect(found[3].title).toBe('Hello world');
+        });
+        it('Finds max label id', ()=>{
+            expect(_linkOrganizer.findMaxLabelId(subject)).toBe(4);
+        });
+    });
+});

package/dist/cjs/utils/replaceMailtoAmp.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "replaceMailtoAmp", {
+    enumerable: true,
+    get: function() {
+        return replaceMailtoAmp;
+    }
+});
+const replaceMailtoAmp = (string)=>{
+    return string.replace(/href="mailto:[^"]*&/g, function(match) {
+        return match.replace(/&/g, '&');
+    });
+};

package/dist/cjs/utils/replaceMailtoAmp.spec.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _replaceMailtoAmp = require("./replaceMailtoAmp");
+describe('replace inside mailto', ()=>{
+    let str = '<a href="mailto:example@example.com?subject=Hello&amp;body=Hello%20world">Send Email</a>';
+    test('replace &amp; with &', ()=>{
+        const newStr = (0, _replaceMailtoAmp.replaceMailtoAmp)(str);
+        expect(newStr).toBe('<a href="mailto:example@example.com?subject=Hello&body=Hello%20world">Send Email</a>');
+    });
+    test('no replace if not inside mailto', ()=>{
+        str = '<a href="https://example.com?subject=Hello&amp;body=Hello%20world">Visit Website</a>';
+        const newStr = (0, _replaceMailtoAmp.replaceMailtoAmp)(str);
+        expect(newStr).toBe('<a href="https://example.com?subject=Hello&amp;body=Hello%20world">Visit Website</a>');
+    });
+    test('no replace if no &amp;', ()=>{
+        str = '<a href="mailto:example@example.com?subject=Hello">Send Email</a>';
+        const newStr = (0, _replaceMailtoAmp.replaceMailtoAmp)(str);
+        expect(newStr).toBe('<a href="mailto:example@example.com?subject=Hello">Send Email</a>');
+    });
+});

package/dist/cjs/utils/specialCharacters.js

@@ -0,0 +1,228 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "specialCharacters", {
+    enumerable: true,
+    get: function() {
+        return specialCharacters;
+    }
+});
+const specialCharacters = [
+    {
+        code: 180,
+        desc: 'acute accent'
+    },
+    {
+        code: 38,
+        desc: 'ampersand'
+    },
+    {
+        code: 166,
+        desc: 'broken vertical bar'
+    },
+    {
+        code: 8226,
+        desc: 'bullet'
+    },
+    {
+        code: 184,
+        desc: 'cedilla'
+    },
+    {
+        code: 162,
+        desc: 'cent'
+    },
+    {
+        code: 169,
+        desc: 'copyright'
+    },
+    {
+        code: 176,
+        desc: 'degree'
+    },
+    {
+        code: 247,
+        desc: 'division'
+    },
+    {
+        code: 189,
+        desc: 'fraction half'
+    },
+    {
+        code: 188,
+        desc: 'fraction quarter'
+    },
+    {
+        code: 190,
+        desc: 'fraction three quarters'
+    },
+    {
+        code: 62,
+        desc: 'greater than'
+    },
+    {
+        code: 161,
+        desc: 'inverted exclamation mark'
+    },
+    {
+        code: 191,
+        desc: 'inverted question mark'
+    },
+    {
+        code: 171,
+        desc: 'left-pointing double angle quotation mark'
+    },
+    {
+        code: 60,
+        desc: 'less than'
+    },
+    {
+        code: 175,
+        desc: 'macron'
+    },
+    {
+        code: 181,
+        desc: 'micro'
+    },
+    {
+        code: 160,
+        desc: 'non-breaking space'
+    },
+    {
+        code: 172,
+        desc: 'not'
+    },
+    {
+        code: 182,
+        desc: 'paragraph'
+    },
+    {
+        code: 177,
+        desc: 'plus-minus'
+    },
+    {
+        code: 34,
+        desc: 'quotation mark'
+    },
+    {
+        code: 174,
+        desc: 'registered'
+    },
+    {
+        code: 187,
+        desc: 'right-pointing double angle quotation mark'
+    },
+    {
+        code: 167,
+        desc: 'section'
+    },
+    {
+        code: 168,
+        desc: 'umlaut/diaeresis'
+    },
+    {
+        code: 215,
+        desc: 'multiplication'
+    },
+    {
+        code: 8482,
+        desc: 'trade mark'
+    },
+    {
+        code: 8364,
+        desc: 'euro'
+    },
+    {
+        code: 163,
+        desc: 'pound'
+    },
+    {
+        code: 165,
+        desc: 'yen'
+    },
+    {
+        code: 8222,
+        desc: 'double low-9 quotation mark'
+    },
+    {
+        code: 710,
+        desc: 'modifier circumflex accent'
+    },
+    {
+        code: 8224,
+        desc: 'dagger'
+    },
+    {
+        code: 8225,
+        desc: 'double dagger'
+    },
+    {
+        code: 8230,
+        desc: 'horizontal ellipsis'
+    },
+    {
+        code: 8220,
+        desc: 'left double quotation mark'
+    },
+    {
+        code: 8249,
+        desc: 'single left-pointing angle quotation mark'
+    },
+    {
+        code: 8216,
+        desc: 'left single quotation mark'
+    },
+    {
+        code: 183,
+        desc: 'middle dot'
+    },
+    {
+        code: 8212,
+        desc: 'em dash'
+    },
+    {
+        code: 8211,
+        desc: 'en dash'
+    },
+    {
+        code: 8240,
+        desc: 'per mille'
+    },
+    {
+        code: 8250,
+        desc: 'single right-pointing angle quotation mark'
+    },
+    {
+        code: 8217,
+        desc: 'right single quotation mark'
+    },
+    {
+        code: 8218,
+        desc: 'single low-9 quotation mark'
+    },
+    {
+        code: 170,
+        desc: 'feminine ordinal indicator'
+    },
+    {
+        code: 186,
+        desc: 'masculine ordinal indicator'
+    },
+    {
+        code: 8221,
+        desc: 'right double quotation mark'
+    },
+    {
+        code: 732,
+        desc: 'small tilde'
+    },
+    {
+        code: 9829,
+        desc: 'black heart'
+    },
+    {
+        code: 9830,
+        desc: 'diamond'
+    }
+];

package/dist/cjs/utils/userAgent.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getCtrlKey", {
+    enumerable: true,
+    get: function() {
+        return getCtrlKey;
+    }
+});
+const _get = _interop_require_default(require("lodash/get"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const userAgent = (0, _get.default)(window, 'navigator.userAgent', '');
+const platform = (0, _get.default)(window, 'navigator.platform', '');
+let ctrlKey = 'Ctrl';
+const tests = {
+    ios: /(iphone os|ipad|iphone|ipod)/i.test(userAgent) && !window.MSStream
+};
+if (tests.ios || /mac(68k|ppc|intel)/i.test(platform)) {
+    ctrlKey = 'Cmd';
+}
+function getCtrlKey() {
+    return ctrlKey;
+}