@handlewithcare/react-prosemirror 2.8.0-tiptap.10 → 2.8.0-tiptap.12

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

@@ -1,76 +0,0 @@
-/* eslint-env mocha */ import assert from 'assert';
-import { getOpeningElement, setParserName, describeIfNotBabylon } from '../helper';
-import elementType from '../../src/elementType';
-describe('elementType tests', ()=>{
-    beforeEach(()=>{
-        setParserName('babel');
-    });
-    it('should export a function', ()=>{
-        const expected = 'function';
-        const actual = typeof elementType;
-        assert.equal(actual, expected);
-    });
-    it('should throw an error if the argument is missing', ()=>{
-        assert.throws(()=>{
-            elementType();
-        }, Error);
-    });
-    it('should throw an error if the argument not a JSX node', ()=>{
-        assert.throws(()=>{
-            elementType({
-                a: 'foo'
-            });
-        }, Error);
-    });
-    it('should return the correct type of the DOM element given its node object', ()=>{
-        const code = '<div />';
-        const node = getOpeningElement(code);
-        const expected = 'div';
-        const actual = elementType(node);
-        assert.equal(actual, expected);
-    });
-    it('should return the correct type of the custom element given its node object', ()=>{
-        const code = '<Slider />';
-        const node = getOpeningElement(code);
-        const expected = 'Slider';
-        const actual = elementType(node);
-        assert.equal(actual, expected);
-    });
-    it('should return the correct type of the custom object element given its node object', ()=>{
-        const code = '<UX.Slider />';
-        const node = getOpeningElement(code);
-        const expected = 'UX.Slider';
-        const actual = elementType(node);
-        assert.equal(actual, expected);
-    });
-    it('should return the correct type of the namespaced element given its node object', ()=>{
-        const code = '<UX:Slider />';
-        const node = getOpeningElement(code);
-        const expected = 'UX:Slider';
-        const actual = elementType(node);
-        assert.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 = getOpeningElement(code);
-        const expected = 'UX.Slider.Blue.Light';
-        const actual = elementType(node);
-        assert.equal(actual, expected);
-    });
-    it('should return this.Component when given its node object', ()=>{
-        const code = '<this.Component />';
-        const node = getOpeningElement(code);
-        const expected = 'this.Component';
-        const actual = elementType(node);
-        assert.equal(actual, expected);
-    });
-    describeIfNotBabylon('fragments', ()=>{
-        it('should work with fragments', ()=>{
-            const code = '<>foo</>';
-            const node = getOpeningElement(code);
-            const expected = '<>';
-            const actual = elementType(node);
-            assert.equal(actual, expected);
-        });
-    });
-});

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

@@ -1,98 +0,0 @@
-/* eslint-env mocha */ import assert from 'assert';
-import includes from 'array-includes';
-import eventHandlers, { eventHandlersByType } from '../../src/eventHandlers';
-describe('eventHandlers', ()=>{
-    it('should contain a list of common JSX event handlers', ()=>{
-        assert([
-            '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)=>includes(eventHandlers, handlerName)));
-    });
-});
-describe('eventHandlersByType', ()=>{
-    it('should be keyed by type', ()=>{
-        assert([
-            'clipboard',
-            'composition',
-            'keyboard',
-            'focus',
-            'form',
-            'mouse',
-            'selection',
-            'touch',
-            'ui',
-            'wheel',
-            'media',
-            'image',
-            'animation',
-            'transition'
-        ].every((type)=>!!eventHandlersByType[type]));
-    });
-});

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

@@ -1,188 +0,0 @@
-/* eslint-env mocha */ import assert from 'assert';
-import entries from 'object.entries';
-import fromEntries from 'object.fromentries';
-import { getOpeningElement, setParserName, fallbackToBabylon } from '../helper';
-import getProp from '../../src/getProp';
-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) {
-    setParserName(parserName);
-    const { source, target, offset } = test;
-    const sourceProps = stripConstructors(getOpeningElement(source).attributes);
-    const targetProps = stripConstructors(getOpeningElement(target).attributes);
-    const prop = 'id';
-    const sourceResult = getProp(sourceProps, prop);
-    const targetResult = getProp(targetProps, prop);
-    if (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.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 fromEntries(entries(o).map((param)=>{
-        let [k, v] = param;
-        return [
-            k,
-            f(v)
-        ];
-    }));
-}

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

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