@handlewithcare/react-prosemirror 2.8.1 → 2.9.0-tiptap.25

package/dist/cjs/cjs/esm/cjs/jsx-ast-utils/__tests__/helper.js

@@ -0,0 +1,118 @@
+/* eslint-env jest */ "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, {
+    changePlugins: function() {
+        return changePlugins;
+    },
+    describeIfNotBabylon: function() {
+        return describeIfNotBabylon;
+    },
+    extractProp: function() {
+        return extractProp;
+    },
+    fallbackToBabylon: function() {
+        return fallbackToBabylon;
+    },
+    getOpeningElement: function() {
+        return getOpeningElement;
+    },
+    setParserName: function() {
+        return setParserName;
+    }
+});
+const _getProp = /*#__PURE__*/ _interop_require_default(require("../src/getProp"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const nodeVersion = parseInt(process.version.match(/^v(\d+)\./)[1], 10);
+const fallbackToBabylon = nodeVersion < 6;
+let parserName;
+const babelParser = fallbackToBabylon ? require('babylon') : require('@babel/parser');
+const flowParser = require('flow-parser');
+const defaultPlugins = [
+    'jsx',
+    'functionBind',
+    'estree',
+    'objectRestSpread',
+    'optionalChaining'
+];
+let plugins = [
+    ...defaultPlugins
+];
+function setParserName(name) {
+    parserName = name;
+}
+function changePlugins(pluginOrFn) {
+    if (Array.isArray(pluginOrFn)) {
+        plugins = pluginOrFn;
+    } else if (typeof pluginOrFn === 'function') {
+        plugins = pluginOrFn(plugins);
+    } else {
+        throw new Error('changePlugins argument should be either an array or a function');
+    }
+}
+beforeEach(()=>{
+    plugins = [
+        ...defaultPlugins
+    ];
+});
+function parse(code) {
+    if (parserName === undefined) {
+        throw new Error('No parser specified');
+    }
+    if (parserName === 'babel') {
+        try {
+            return babelParser.parse(code, {
+                plugins,
+                sourceFilename: 'test.js'
+            });
+        } catch (_) {
+            // eslint-disable-next-line no-console
+            console.warn(`Failed to parse with ${fallbackToBabylon ? 'babylon' : 'Babel'} parser.`);
+        }
+    }
+    if (parserName === 'flow') {
+        try {
+            return flowParser.parse(code, {
+                plugins
+            });
+        } catch (_) {
+            // eslint-disable-next-line no-console
+            console.warn('Failed to parse with the Flow parser');
+        }
+    }
+    throw new Error(`The parser ${parserName} is not yet supported for testing.`);
+}
+function getOpeningElement(code) {
+    const parsedCode = parse(code);
+    let body;
+    if (parsedCode.program) {
+        // eslint-disable-next-line prefer-destructuring
+        body = parsedCode.program.body;
+    } else {
+        // eslint-disable-next-line prefer-destructuring
+        body = parsedCode.body;
+    }
+    if (Array.isArray(body) && body[0] != null) {
+        const [{ expression }] = body;
+        return expression.type === 'JSXFragment' ? expression.openingFragment : expression.openingElement;
+    }
+    return null;
+}
+function extractProp(code) {
+    let prop = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 'foo';
+    const node = getOpeningElement(code);
+    const { attributes: props } = node;
+    return (0, _getProp.default)(props, prop);
+}
+const describeIfNotBabylon = fallbackToBabylon ? describe.skip : describe;

package/dist/cjs/cjs/esm/cjs/jsx-ast-utils/__tests__/src/elementType-test.js

@@ -0,0 +1,85 @@
+/* eslint-env mocha */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _assert = /*#__PURE__*/ _interop_require_default(require("assert"));
+const _helper = require("../helper");
+const _elementType = /*#__PURE__*/ _interop_require_default(require("../../src/elementType"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+describe('elementType tests', ()=>{
+    beforeEach(()=>{
+        (0, _helper.setParserName)('babel');
+    });
+    it('should export a function', ()=>{
+        const expected = 'function';
+        const actual = typeof _elementType.default;
+        _assert.default.equal(actual, expected);
+    });
+    it('should throw an error if the argument is missing', ()=>{
+        _assert.default.throws(()=>{
+            (0, _elementType.default)();
+        }, Error);
+    });
+    it('should throw an error if the argument not a JSX node', ()=>{
+        _assert.default.throws(()=>{
+            (0, _elementType.default)({
+                a: 'foo'
+            });
+        }, Error);
+    });
+    it('should return the correct type of the DOM element given its node object', ()=>{
+        const code = '<div />';
+        const node = (0, _helper.getOpeningElement)(code);
+        const expected = 'div';
+        const actual = (0, _elementType.default)(node);
+        _assert.default.equal(actual, expected);
+    });
+    it('should return the correct type of the custom element given its node object', ()=>{
+        const code = '<Slider />';
+        const node = (0, _helper.getOpeningElement)(code);
+        const expected = 'Slider';
+        const actual = (0, _elementType.default)(node);
+        _assert.default.equal(actual, expected);
+    });
+    it('should return the correct type of the custom object element given its node object', ()=>{
+        const code = '<UX.Slider />';
+        const node = (0, _helper.getOpeningElement)(code);
+        const expected = 'UX.Slider';
+        const actual = (0, _elementType.default)(node);
+        _assert.default.equal(actual, expected);
+    });
+    it('should return the correct type of the namespaced element given its node object', ()=>{
+        const code = '<UX:Slider />';
+        const node = (0, _helper.getOpeningElement)(code);
+        const expected = 'UX:Slider';
+        const actual = (0, _elementType.default)(node);
+        _assert.default.equal(actual, expected);
+    });
+    it('should return the correct type of the multiple custom object element given its node object', ()=>{
+        const code = '<UX.Slider.Blue.Light />';
+        const node = (0, _helper.getOpeningElement)(code);
+        const expected = 'UX.Slider.Blue.Light';
+        const actual = (0, _elementType.default)(node);
+        _assert.default.equal(actual, expected);
+    });
+    it('should return this.Component when given its node object', ()=>{
+        const code = '<this.Component />';
+        const node = (0, _helper.getOpeningElement)(code);
+        const expected = 'this.Component';
+        const actual = (0, _elementType.default)(node);
+        _assert.default.equal(actual, expected);
+    });
+    (0, _helper.describeIfNotBabylon)('fragments', ()=>{
+        it('should work with fragments', ()=>{
+            const code = '<>foo</>';
+            const node = (0, _helper.getOpeningElement)(code);
+            const expected = '<>';
+            const actual = (0, _elementType.default)(node);
+            _assert.default.equal(actual, expected);
+        });
+    });
+});

package/dist/cjs/cjs/esm/cjs/jsx-ast-utils/__tests__/src/eventHandlers-test.js

@@ -0,0 +1,148 @@
+/* eslint-env mocha */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _assert = /*#__PURE__*/ _interop_require_default(require("assert"));
+const _arrayincludes = /*#__PURE__*/ _interop_require_default(require("array-includes"));
+const _eventHandlers = /*#__PURE__*/ _interop_require_wildcard(require("../../src/eventHandlers"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+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 = {
+        __proto__: null
+    };
+    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('eventHandlers', ()=>{
+    it('should contain a list of common JSX event handlers', ()=>{
+        (0, _assert.default)([
+            'onCopy',
+            'onCut',
+            'onPaste',
+            'onCompositionEnd',
+            'onCompositionStart',
+            'onCompositionUpdate',
+            'onKeyDown',
+            'onKeyPress',
+            'onKeyUp',
+            'onFocus',
+            'onBlur',
+            'onChange',
+            'onInput',
+            'onSubmit',
+            'onClick',
+            'onContextMenu',
+            'onDblClick',
+            'onDoubleClick',
+            'onDrag',
+            'onDragEnd',
+            'onDragEnter',
+            'onDragExit',
+            'onDragLeave',
+            'onDragOver',
+            'onDragStart',
+            'onDrop',
+            'onMouseDown',
+            'onMouseEnter',
+            'onMouseLeave',
+            'onMouseMove',
+            'onMouseOut',
+            'onMouseOver',
+            'onMouseUp',
+            'onSelect',
+            'onTouchCancel',
+            'onTouchEnd',
+            'onTouchMove',
+            'onTouchStart',
+            'onScroll',
+            'onWheel',
+            'onAbort',
+            'onCanPlay',
+            'onCanPlayThrough',
+            'onDurationChange',
+            'onEmptied',
+            'onEncrypted',
+            'onEnded',
+            'onError',
+            'onLoadedData',
+            'onLoadedMetadata',
+            'onLoadStart',
+            'onPause',
+            'onPlay',
+            'onPlaying',
+            'onProgress',
+            'onRateChange',
+            'onSeeked',
+            'onSeeking',
+            'onStalled',
+            'onSuspend',
+            'onTimeUpdate',
+            'onVolumeChange',
+            'onWaiting',
+            'onLoad',
+            'onError',
+            'onAnimationStart',
+            'onAnimationEnd',
+            'onAnimationIteration',
+            'onTransitionEnd'
+        ].every((handlerName)=>(0, _arrayincludes.default)(_eventHandlers.default, handlerName)));
+    });
+});
+describe('eventHandlersByType', ()=>{
+    it('should be keyed by type', ()=>{
+        (0, _assert.default)([
+            'clipboard',
+            'composition',
+            'keyboard',
+            'focus',
+            'form',
+            'mouse',
+            'selection',
+            'touch',
+            'ui',
+            'wheel',
+            'media',
+            'image',
+            'animation',
+            'transition'
+        ].every((type)=>!!_eventHandlers.eventHandlersByType[type]));
+    });
+});

package/dist/cjs/cjs/esm/cjs/jsx-ast-utils/__tests__/src/getProp-parser-test.js

@@ -0,0 +1,197 @@
+/* eslint-env mocha */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _assert = /*#__PURE__*/ _interop_require_default(require("assert"));
+const _objectentries = /*#__PURE__*/ _interop_require_default(require("object.entries"));
+const _objectfromentries = /*#__PURE__*/ _interop_require_default(require("object.fromentries"));
+const _helper = require("../helper");
+const _getProp = /*#__PURE__*/ _interop_require_default(require("../../src/getProp"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const literal = {
+    source: '<div {...{ id: "foo" }} />',
+    target: '<div id="foo" />',
+    offset: {
+        keyOffset: -6,
+        valueOffset: -7
+    }
+};
+const expression1 = {
+    source: '<div {...{ id }} />',
+    target: '<div id={id} />',
+    offset: {
+        keyOffset: -6,
+        valueOffset: -2
+    }
+};
+const expression2 = {
+    source: '<div {...{ id: `foo${bar}baz` }} />',
+    target: '<div id={`foo${bar}baz`} />',
+    offset: {
+        keyOffset: -6,
+        valueOffset: -6
+    }
+};
+describe('getProp', ()=>{
+    it('should create the correct AST for literal with flow parser', ()=>{
+        actualTest('flow', literal);
+    });
+    it('should create the correct AST for literal with babel parser', ()=>{
+        actualTest('babel', literal);
+    });
+    it('should create the correct AST for expression with flow parser (1)', ()=>{
+        actualTest('flow', expression1);
+    });
+    it('should create the correct AST for expression with babel parser (1)', ()=>{
+        actualTest('babel', expression1);
+    });
+    it('should create the correct AST for expression with flow parser (2)', ()=>{
+        actualTest('flow', expression2);
+    });
+    it('should create the correct AST for expression with babel parser (2)', ()=>{
+        actualTest('babel', expression2);
+    });
+});
+function actualTest(parserName, test) {
+    (0, _helper.setParserName)(parserName);
+    const { source, target, offset } = test;
+    const sourceProps = stripConstructors((0, _helper.getOpeningElement)(source).attributes);
+    const targetProps = stripConstructors((0, _helper.getOpeningElement)(target).attributes);
+    const prop = 'id';
+    const sourceResult = (0, _getProp.default)(sourceProps, prop);
+    const targetResult = (0, _getProp.default)(targetProps, prop);
+    if (_helper.fallbackToBabylon && parserName === 'babel' && test === literal) {
+        // Babylon (node < 6) adds an `extra: null` prop to a literal if it is parsed from a
+        // JSXAttribute, other literals don't get this.
+        sourceResult.value.extra = null;
+    }
+    _assert.default.deepStrictEqual(adjustLocations(sourceResult, offset), adjustRange(targetResult));
+}
+function adjustRange(param) {
+    let { name, value: { expression, ...value }, ...node } = param;
+    return {
+        ...adjustNodeRange(node),
+        name: adjustNodeRange(name),
+        value: {
+            ...adjustNodeRange(value),
+            ...expression ? {
+                expression: adjustNodeRangeRecursively(expression)
+            } : {}
+        }
+    };
+}
+function adjustNodeRange(node) {
+    if (!node.loc) {
+        return node;
+    }
+    const [start, end] = node.range || [
+        node.start,
+        node.end
+    ];
+    return {
+        ...node,
+        end: undefined,
+        range: [
+            start,
+            end
+        ],
+        start: undefined
+    };
+}
+function adjustNodeRangeRecursively(node) {
+    if (Array.isArray(node)) {
+        return node.map(adjustNodeRangeRecursively);
+    }
+    if (node && typeof node === 'object') {
+        return adjustNodeRange(mapValues(node, adjustNodeRangeRecursively));
+    }
+    return node;
+}
+function stripConstructors(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+function adjustLocations(node, param) {
+    let { keyOffset, valueOffset } = param;
+    const hasExpression = !!node.value.expression;
+    return {
+        ...adjustNodeLocations(node, {
+            startOffset: keyOffset,
+            endOffset: valueOffset + (hasExpression ? 1 : 0)
+        }),
+        name: adjustNodeLocations(node.name, {
+            startOffset: keyOffset,
+            endOffset: keyOffset
+        }),
+        value: {
+            ...adjustNodeLocations(node.value, {
+                startOffset: valueOffset - (hasExpression ? 1 : 0),
+                endOffset: valueOffset + (hasExpression ? 1 : 0)
+            }),
+            ...hasExpression ? {
+                expression: adjustLocationsRecursively(node.value.expression, {
+                    startOffset: valueOffset,
+                    endOffset: valueOffset
+                })
+            } : {}
+        }
+    };
+}
+function adjustNodeLocations(node, param) {
+    let { startOffset, endOffset } = param;
+    if (!node.loc) {
+        return node;
+    }
+    const [start, end] = node.range || [];
+    return {
+        ...node,
+        end: undefined,
+        loc: {
+            ...node.loc,
+            start: {
+                ...node.loc.start,
+                column: node.loc.start.column + startOffset
+            },
+            end: {
+                ...node.loc.end,
+                column: node.loc.end.column + endOffset
+            }
+        },
+        range: [
+            start + startOffset,
+            end + endOffset
+        ],
+        start: undefined
+    };
+}
+function adjustLocationsRecursively(node, param) {
+    let { startOffset, endOffset } = param;
+    if (Array.isArray(node)) {
+        return node.map((x)=>adjustLocationsRecursively(x, {
+                startOffset,
+                endOffset
+            }));
+    }
+    if (node && typeof node === 'object') {
+        return adjustNodeLocations(mapValues(node, (x)=>adjustLocationsRecursively(x, {
+                startOffset,
+                endOffset
+            })), {
+            startOffset,
+            endOffset
+        });
+    }
+    return node;
+}
+function mapValues(o, f) {
+    return (0, _objectfromentries.default)((0, _objectentries.default)(o).map((param)=>{
+        let [k, v] = param;
+        return [
+            k,
+            f(v)
+        ];
+    }));
+}

package/dist/cjs/cjs/esm/cjs/jsx-ast-utils/__tests__/src/getProp-test.js

@@ -0,0 +1,128 @@
+/* eslint-env mocha */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _assert = /*#__PURE__*/ _interop_require_default(require("assert"));
+const _helper = require("../helper");
+const _getProp = /*#__PURE__*/ _interop_require_default(require("../../src/getProp"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+describe('getProp', ()=>{
+    beforeEach(()=>{
+        (0, _helper.setParserName)('babel');
+    });
+    it('should export a function', ()=>{
+        const expected = 'function';
+        const actual = typeof _getProp.default;
+        _assert.default.equal(actual, expected);
+    });
+    it('should return undefined if no arguments are provided', ()=>{
+        const expected = undefined;
+        const actual = (0, _getProp.default)();
+        _assert.default.equal(actual, expected);
+    });
+    it('should return undefined if the attribute is absent', ()=>{
+        const code = '<div />';
+        const node = (0, _helper.getOpeningElement)(code);
+        const { attributes: props } = node;
+        const prop = 'id';
+        const expected = undefined;
+        const actual = (0, _getProp.default)(props, prop);
+        _assert.default.equal(actual, expected);
+    });
+    it('should return the correct attribute if the attribute exists', ()=>{
+        const code = '<div id="foo" />';
+        const node = (0, _helper.getOpeningElement)(code);
+        const { attributes: props } = node;
+        const prop = 'id';
+        const expected = 'id';
+        const actual = (0, _getProp.default)(props, prop).name.name;
+        _assert.default.equal(actual, expected);
+    });
+    it('should return the correct attribute if the attribute exists in spread', ()=>{
+        const code = '<div {...{ id: "foo" }} />';
+        const node = (0, _helper.getOpeningElement)(code);
+        const { attributes: props } = node;
+        const prop = 'ID';
+        const expected = 'id';
+        const actual = (0, _getProp.default)(props, prop).name.name;
+        _assert.default.equal(actual, expected);
+    });
+    it('should return the correct attribute if the attribute exists in spread as an expression', ()=>{
+        const code = '<div {...{ id }} />';
+        const node = (0, _helper.getOpeningElement)(code);
+        const { attributes: props } = node;
+        const prop = 'id';
+        const expected = 'id';
+        const actual = (0, _getProp.default)(props, prop);
+        const actualName = actual.name.name;
+        const actualValue = actual.value.expression.name;
+        _assert.default.equal(actualName, expected);
+        _assert.default.equal(actualValue, expected);
+    });
+    it('should return the correct attribute if the attribute exists in spread (case sensitive)', ()=>{
+        const code = '<div {...{ id: "foo" }} />';
+        const node = (0, _helper.getOpeningElement)(code);
+        const { attributes: props } = node;
+        const prop = 'id';
+        const options = {
+            ignoreCase: false
+        };
+        const expected = 'id';
+        const actual = (0, _getProp.default)(props, prop, options).name.name;
+        _assert.default.equal(actual, expected);
+    });
+    it('should return undefined if the attribute does not exist in spread (case sensitive)', ()=>{
+        const code = '<div {...{ id: "foo" }} />';
+        const node = (0, _helper.getOpeningElement)(code);
+        const { attributes: props } = node;
+        const prop = 'ID';
+        const options = {
+            ignoreCase: false
+        };
+        const expected = undefined;
+        const actual = (0, _getProp.default)(props, prop, options);
+        _assert.default.equal(actual, expected);
+    });
+    it('should return undefined for key in spread', ()=>{
+        // https://github.com/reactjs/rfcs/pull/107
+        const code = '<div {...{ key }} />';
+        const node = (0, _helper.getOpeningElement)(code);
+        const { attributes: props } = node;
+        const prop = 'key';
+        const expected = undefined;
+        const actual = (0, _getProp.default)(props, prop);
+        _assert.default.equal(actual, expected);
+    });
+    it('should return undefined if the attribute may exist in spread', ()=>{
+        const code = '<div {...props} />';
+        const node = (0, _helper.getOpeningElement)(code);
+        const { attributes: props } = node;
+        const prop = 'id';
+        const expected = undefined;
+        const actual = (0, _getProp.default)(props, prop);
+        _assert.default.equal(actual, expected);
+    });
+    it('should not crash if the spread contains a spread', ()=>{
+        const code = '<div {...{ ...props }} />';
+        const node = (0, _helper.getOpeningElement)(code);
+        const { attributes: props } = node;
+        const prop = 'id';
+        (0, _getProp.default)(props, prop);
+    });
+    it('should return undefined if the attribute is considered absent in case-sensitive mode', ()=>{
+        const code = '<div ID="foo" />';
+        const node = (0, _helper.getOpeningElement)(code);
+        const { attributes: props } = node;
+        const prop = 'id';
+        const options = {
+            ignoreCase: false
+        };
+        const expected = undefined;
+        const actual = (0, _getProp.default)(props, prop, options);
+        _assert.default.equal(actual, expected);
+    });
+});