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

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

@@ -1,350 +0,0 @@
-/* eslint-env mocha */ import assert from 'assert';
-import { getOpeningElement, setParserName } from '../helper';
-import hasProp, { hasAnyProp, hasEveryProp } from '../../src/hasProp';
-describe('hasProp', ()=>{
-    beforeEach(()=>{
-        setParserName('babel');
-    });
-    it('should export a function', ()=>{
-        const expected = 'function';
-        const actual = typeof hasProp;
-        assert.equal(actual, expected);
-    });
-    it('should return false if no arguments are provided', ()=>{
-        const expected = false;
-        const actual = hasProp();
-        assert.equal(actual, expected);
-    });
-    it('should return false if the prop is absent', ()=>{
-        const code = '<div />';
-        const node = getOpeningElement(code);
-        const { attributes: props } = node;
-        const prop = 'id';
-        const expected = false;
-        const actual = hasProp(props, prop);
-        assert.equal(actual, expected);
-    });
-    it('should return true if the prop exists', ()=>{
-        const code = '<div id="foo" />';
-        const node = getOpeningElement(code);
-        const { attributes: props } = node;
-        const prop = 'id';
-        const expected = true;
-        const actual = hasProp(props, prop);
-        assert.equal(actual, expected);
-    });
-    it('should return true if the prop may exist in spread loose mode', ()=>{
-        const code = '<div {...props} />';
-        const node = getOpeningElement(code);
-        const { attributes: props } = node;
-        const prop = 'id';
-        const options = {
-            spreadStrict: false
-        };
-        const expected = true;
-        const actual = hasProp(props, prop, options);
-        assert.equal(actual, expected);
-    });
-    it('should return false if the prop 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 = false;
-        const actual = hasProp(props, prop, options);
-        assert.equal(actual, expected);
-    });
-});
-describe('hasAnyProp tests', ()=>{
-    it('should export a function', ()=>{
-        const expected = 'function';
-        const actual = typeof hasAnyProp;
-        assert.equal(actual, expected);
-    });
-    it('should return false if no arguments are provided', ()=>{
-        const expected = false;
-        const actual = hasAnyProp();
-        assert.equal(actual, expected);
-    });
-    it('should return false if the prop is absent', ()=>{
-        const code = '<div />';
-        const node = getOpeningElement(code);
-        const { attributes: props } = node;
-        const prop = 'id';
-        const expected = false;
-        const actual = hasAnyProp(props, prop);
-        assert.equal(actual, expected);
-    });
-    it('should return false if all props are absent in array', ()=>{
-        const code = '<div />';
-        const node = getOpeningElement(code);
-        const { attributes: props } = node;
-        const propsToCheck = [
-            'id',
-            'className'
-        ];
-        const expected = false;
-        const actual = hasAnyProp(props, propsToCheck);
-        assert.equal(actual, expected);
-    });
-    it('should return false if all props are absent in space delimited string', ()=>{
-        const code = '<div />';
-        const node = getOpeningElement(code);
-        const { attributes: props } = node;
-        const propsToCheck = 'id className';
-        const expected = false;
-        const actual = hasAnyProp(props, propsToCheck);
-        assert.equal(actual, expected);
-    });
-    it('should return true if the prop exists', ()=>{
-        const code = '<div id="foo" />';
-        const node = getOpeningElement(code);
-        const { attributes: props } = node;
-        const prop = 'id';
-        const expected = true;
-        const actual = hasAnyProp(props, prop);
-        assert.equal(actual, expected);
-    });
-    it('should return true if any prop exists in array', ()=>{
-        const code = '<div id="foo" />';
-        const node = getOpeningElement(code);
-        const { attributes: props } = node;
-        const prop = [
-            'className',
-            'id'
-        ];
-        const expected = true;
-        const actual = hasAnyProp(props, prop);
-        assert.equal(actual, expected);
-    });
-    it('should return true if any prop exists in space delimited string', ()=>{
-        const code = '<div id="foo" />';
-        const node = getOpeningElement(code);
-        const { attributes: props } = node;
-        const prop = 'className id';
-        const expected = true;
-        const actual = hasAnyProp(props, prop);
-        assert.equal(actual, expected);
-    });
-    it('should return true if the prop may exist in spread loose mode', ()=>{
-        const code = '<div {...props} />';
-        const node = getOpeningElement(code);
-        const { attributes: props } = node;
-        const prop = 'id';
-        const options = {
-            spreadStrict: false
-        };
-        const expected = true;
-        const actual = hasAnyProp(props, prop, options);
-        assert.equal(actual, expected);
-    });
-    it('should return true if any prop may exist in spread loose mode', ()=>{
-        const code = '<div {...props} />';
-        const node = getOpeningElement(code);
-        const { attributes: props } = node;
-        const prop = [
-            'id',
-            'className'
-        ];
-        const options = {
-            spreadStrict: false
-        };
-        const expected = true;
-        const actual = hasAnyProp(props, prop, options);
-        assert.equal(actual, expected);
-    });
-    it('should return false if the prop 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 = false;
-        const actual = hasAnyProp(props, prop, options);
-        assert.equal(actual, expected);
-    });
-    it('should return false if all props are considered absent in case-sensitive mode', ()=>{
-        const code = '<div ID="foo" />';
-        const node = getOpeningElement(code);
-        const { attributes: props } = node;
-        const prop = [
-            'id',
-            'iD',
-            'className'
-        ];
-        const options = {
-            ignoreCase: false
-        };
-        const expected = false;
-        const actual = hasAnyProp(props, prop, options);
-        assert.equal(actual, expected);
-    });
-});
-describe('hasEveryProp tests', ()=>{
-    it('should export a function', ()=>{
-        const expected = 'function';
-        const actual = typeof hasEveryProp;
-        assert.equal(actual, expected);
-    });
-    it('should return true if no arguments are provided', ()=>{
-        const expected = true;
-        const actual = hasEveryProp();
-        assert.equal(actual, expected);
-    });
-    it('should return false if the prop is absent', ()=>{
-        const code = '<div />';
-        const node = getOpeningElement(code);
-        const { attributes: props } = node;
-        const prop = 'id';
-        const expected = false;
-        const actual = hasEveryProp(props, prop);
-        assert.equal(actual, expected);
-    });
-    it('should return false if any props are absent in array', ()=>{
-        const code = '<div id="foo" />';
-        const node = getOpeningElement(code);
-        const { attributes: props } = node;
-        const propsToCheck = [
-            'id',
-            'className'
-        ];
-        const expected = false;
-        const actual = hasEveryProp(props, propsToCheck);
-        assert.equal(actual, expected);
-    });
-    it('should return false if all props are absent in array', ()=>{
-        const code = '<div />';
-        const node = getOpeningElement(code);
-        const { attributes: props } = node;
-        const propsToCheck = [
-            'id',
-            'className'
-        ];
-        const expected = false;
-        const actual = hasEveryProp(props, propsToCheck);
-        assert.equal(actual, expected);
-    });
-    it('should return false if any props are absent in space delimited string', ()=>{
-        const code = '<div id="foo" />';
-        const node = getOpeningElement(code);
-        const { attributes: props } = node;
-        const propsToCheck = 'id className';
-        const expected = false;
-        const actual = hasEveryProp(props, propsToCheck);
-        assert.equal(actual, expected);
-    });
-    it('should return false if all props are absent in space delimited string', ()=>{
-        const code = '<div />';
-        const node = getOpeningElement(code);
-        const { attributes: props } = node;
-        const propsToCheck = 'id className';
-        const expected = false;
-        const actual = hasEveryProp(props, propsToCheck);
-        assert.equal(actual, expected);
-    });
-    it('should return true if the prop exists', ()=>{
-        const code = '<div id="foo" />';
-        const node = getOpeningElement(code);
-        const { attributes: props } = node;
-        const prop = 'id';
-        const expected = true;
-        const actual = hasEveryProp(props, prop);
-        assert.equal(actual, expected);
-    });
-    it('should return true if all props exist in array', ()=>{
-        const code = '<div id="foo" className="box" />';
-        const node = getOpeningElement(code);
-        const { attributes: props } = node;
-        const prop = [
-            'className',
-            'id'
-        ];
-        const expected = true;
-        const actual = hasEveryProp(props, prop);
-        assert.equal(actual, expected);
-    });
-    it('should return true if all props exist in space delimited string', ()=>{
-        const code = '<div id="foo" className="box" />';
-        const node = getOpeningElement(code);
-        const { attributes: props } = node;
-        const prop = 'className id';
-        const expected = true;
-        const actual = hasEveryProp(props, prop);
-        assert.equal(actual, expected);
-    });
-    it('should return true if the props may exist in spread loose mode', ()=>{
-        const code = '<div {...props} />';
-        const node = getOpeningElement(code);
-        const { attributes: props } = node;
-        const prop = 'id';
-        const options = {
-            spreadStrict: false
-        };
-        const expected = true;
-        const actual = hasEveryProp(props, prop, options);
-        assert.equal(actual, expected);
-    });
-    it('should return true if all props may exist in spread loose mode', ()=>{
-        const code = '<div {...props} />';
-        const node = getOpeningElement(code);
-        const { attributes: props } = node;
-        const prop = [
-            'id',
-            'className'
-        ];
-        const options = {
-            spreadStrict: false
-        };
-        const expected = true;
-        const actual = hasEveryProp(props, prop, options);
-        assert.equal(actual, expected);
-    });
-    it('should return false if the prop 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 = false;
-        const actual = hasEveryProp(props, prop, options);
-        assert.equal(actual, expected);
-    });
-    it('should return false if all props are considered absent in case-sensitive mode', ()=>{
-        const code = '<div ID="foo" />';
-        const node = getOpeningElement(code);
-        const { attributes: props } = node;
-        const prop = [
-            'id',
-            'iD',
-            'className'
-        ];
-        const options = {
-            ignoreCase: false
-        };
-        const expected = false;
-        const actual = hasEveryProp(props, prop, options);
-        assert.equal(actual, expected);
-    });
-    it('should return true if all props are considered present in case-sensitive mode', ()=>{
-        const code = '<div ID="foo" className="box" />';
-        const node = getOpeningElement(code);
-        const { attributes: props } = node;
-        const prop = [
-            'ID',
-            'className'
-        ];
-        const options = {
-            ignoreCase: false
-        };
-        const expected = true;
-        const actual = hasEveryProp(props, prop, options);
-        assert.equal(actual, expected);
-    });
-});

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

@@ -1,24 +0,0 @@
-/* eslint-env mocha */ import fs from 'fs';
-import path from 'path';
-import assert from 'assert';
-import core from '../../src/index';
-const src = fs.readdirSync(path.resolve(__dirname, '../../src')).filter((f)=>f.indexOf('.js') >= 0).map((f)=>path.basename(f, '.js'));
-describe('main export', ()=>{
-    it('should export an object', ()=>{
-        const expected = 'object';
-        const actual = typeof core;
-        assert.equal(actual, expected);
-    });
-    src.filter((f)=>f !== 'index').forEach((f)=>{
-        it(`should export ${f}`, ()=>{
-            assert.equal(core[f], require(path.join('../../src/', f)).default // eslint-disable-line
-            );
-        });
-        it(`should export ${f} from root`, ()=>{
-            const file = `${f}.js`;
-            const expected = true;
-            const actual = fs.statSync(path.join(path.resolve('.'), file)).isFile();
-            assert.equal(actual, expected);
-        });
-    });
-});

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

@@ -1,37 +0,0 @@
-/* eslint-env mocha */ import assert from 'assert';
-import { extractProp, setParserName } from '../helper';
-import propName from '../../src/propName';
-describe('propName', ()=>{
-    beforeEach(()=>{
-        setParserName('babel');
-    });
-    it('should export a function', ()=>{
-        const expected = 'function';
-        const actual = typeof propName;
-        assert.equal(actual, expected);
-    });
-    it('should throw an error if the argument is missing', ()=>{
-        assert.throws(()=>{
-            propName();
-        }, Error);
-    });
-    it('should throw an error if the argument not a JSX node', ()=>{
-        assert.throws(()=>{
-            propName({
-                a: 'foo'
-            });
-        }, Error);
-    });
-    it('should return correct name for normal prop', ()=>{
-        const prop = extractProp('<div foo="bar" />');
-        const expected = 'foo';
-        const actual = propName(prop);
-        assert.equal(actual, expected);
-    });
-    it('should return correct name for namespaced prop', ()=>{
-        const prop = extractProp('<div foo:bar="baz" />', 'foo:bar');
-        const expected = 'foo:bar';
-        const actual = propName(prop);
-        assert.equal(actual, expected);
-    });
-});

package/dist/esm/esm/esm/plugins/__tests__/reactKeys.test.js

@@ -1,77 +0,0 @@
-/* eslint-disable @typescript-eslint/no-non-null-assertion */ import { Schema } from "prosemirror-model";
-import { EditorState } from "prosemirror-state";
-import { reactKeys, reactKeysPluginKey } from "../reactKeys.js";
-const schema = new Schema({
-    nodes: {
-        doc: {
-            content: "block+"
-        },
-        paragraph: {
-            group: "block",
-            content: "inline*"
-        },
-        list: {
-            group: "block",
-            content: "list_item+"
-        },
-        list_item: {
-            content: "inline*"
-        },
-        text: {
-            group: "inline"
-        }
-    }
-});
-describe("reactNodeViewPlugin", ()=>{
-    it("should create a unique key for each node", ()=>{
-        const editorState = EditorState.create({
-            doc: schema.topNodeType.create(null, [
-                schema.nodes.paragraph.create(),
-                schema.nodes.paragraph.create(),
-                schema.nodes.paragraph.create()
-            ]),
-            plugins: [
-                reactKeys()
-            ]
-        });
-        const pluginState = reactKeysPluginKey.getState(editorState);
-        expect(pluginState.posToKey.size).toBe(3);
-    });
-    it("should maintain key stability when possible", ()=>{
-        const initialEditorState = EditorState.create({
-            doc: schema.topNodeType.create(null, [
-                schema.nodes.paragraph.create({}, schema.text("Hello")),
-                schema.nodes.paragraph.create(),
-                schema.nodes.paragraph.create()
-            ]),
-            plugins: [
-                reactKeys()
-            ]
-        });
-        const initialPluginState = reactKeysPluginKey.getState(initialEditorState);
-        const nextEditorState = initialEditorState.apply(initialEditorState.tr.insertText(", world!", 6));
-        const nextPluginState = reactKeysPluginKey.getState(nextEditorState);
-        expect(Array.from(initialPluginState.keyToPos.keys())).toEqual(Array.from(nextPluginState.keyToPos.keys()));
-    });
-    it("should create unique keys for new nodes", ()=>{
-        const initialEditorState = EditorState.create({
-            doc: schema.topNodeType.create(null, [
-                schema.nodes.paragraph.create(),
-                schema.nodes.paragraph.create(),
-                schema.nodes.paragraph.create()
-            ]),
-            plugins: [
-                reactKeys()
-            ]
-        });
-        const initialPluginState = reactKeysPluginKey.getState(initialEditorState);
-        const nextEditorState = initialEditorState.apply(initialEditorState.tr.insert(0, schema.nodes.list.createAndFill()));
-        const nextPluginState = reactKeysPluginKey.getState(nextEditorState);
-        // Adds new keys for new nodes
-        expect(nextPluginState.keyToPos.size).toBe(5);
-        // Maintains keys for previous nodes that are still there
-        Array.from(initialPluginState.keyToPos.keys()).forEach((key)=>{
-            expect(Array.from(nextPluginState.keyToPos.keys())).toContain(key);
-        });
-    });
-});

package/dist/esm/esm/esm/tsconfig-paths/lib/__tests__/config-loader.test.d.js

@@ -1 +0,0 @@
-export { };

package/dist/esm/esm/esm/tsconfig-paths/lib/__tests__/config-loader.test.js

@@ -1,97 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-var config_loader_1 = require("../config-loader");
-var path_1 = require("path");
-describe("config-loader", function() {
-    it("should use explicitParams when set", function() {
-        var result = (0, config_loader_1.configLoader)({
-            explicitParams: {
-                baseUrl: "/foo/bar",
-                paths: {
-                    asd: [
-                        "asd"
-                    ]
-                }
-            },
-            cwd: "/baz"
-        });
-        var successResult = result;
-        // assert.equal(successResult.resultType, "success");
-        // assert.equal(successResult.absoluteBaseUrl, "/foo/bar");
-        // assert.equal(successResult.paths["asd"][0], "asd");
-        expect(successResult.resultType).toBe("success");
-        expect(successResult.absoluteBaseUrl).toBe("/foo/bar");
-        expect(successResult.paths["asd"][0]).toBe("asd");
-    });
-    it("should use explicitParams when set and add cwd when path is relative", function() {
-        var result = (0, config_loader_1.configLoader)({
-            explicitParams: {
-                baseUrl: "bar/",
-                paths: {
-                    asd: [
-                        "asd"
-                    ]
-                }
-            },
-            cwd: "/baz"
-        });
-        var successResult = result;
-        // assert.equal(successResult.resultType, "success");
-        // assert.equal(successResult.absoluteBaseUrl, join("/baz", "bar/"));
-        expect(successResult.resultType).toBe("success");
-        expect(successResult.absoluteBaseUrl).toBe((0, path_1.join)("/baz", "bar/"));
-    });
-    it("should fallback to tsConfigLoader when explicitParams is not set", function() {
-        var result = (0, config_loader_1.configLoader)({
-            explicitParams: undefined,
-            cwd: "/baz",
-            // tslint:disable-next-line:no-any
-            tsConfigLoader: function(_) {
-                return {
-                    tsConfigPath: "/baz/tsconfig.json",
-                    baseUrl: "./src",
-                    paths: {}
-                };
-            }
-        });
-        var successResult = result;
-        // assert.equal(successResult.resultType, "success");
-        // assert.equal(successResult.absoluteBaseUrl, join("/baz", "src"));
-        expect(successResult.resultType).toBe("success");
-        expect(successResult.absoluteBaseUrl).toBe((0, path_1.join)("/baz", "src"));
-    });
-    it("should show an error message when baseUrl is missing", function() {
-        var result = (0, config_loader_1.configLoader)({
-            explicitParams: undefined,
-            cwd: "/baz",
-            // tslint:disable-next-line:no-any
-            tsConfigLoader: function(_) {
-                return {
-                    tsConfigPath: "/baz/tsconfig.json",
-                    baseUrl: undefined,
-                    paths: {}
-                };
-            }
-        });
-        var failResult = result;
-        // assert.equal(failResult.resultType, "failed");
-        // assert.isTrue(failResult.message.indexOf("baseUrl") > -1);
-        expect(failResult.resultType).toBe("failed");
-        expect(failResult.message.indexOf("baseUrl") > -1).toBeTruthy();
-    });
-    it("should presume cwd to be a tsconfig file when loadConfig is called with absolute path to tsconfig.json", function() {
-        // using tsconfig-named.json to ensure that future changes to fix
-        // https://github.com/dividab/tsconfig-paths/issues/31
-        // do not pass this test case just because of a directory walk looking
-        // for tsconfig.json
-        var configFile = (0, path_1.join)(__dirname, "tsconfig-named.json");
-        var result = (0, config_loader_1.loadConfig)(configFile);
-        var successResult = result;
-        // assert.equal(successResult.resultType, "success");
-        // assert.equal(successResult.configFileAbsolutePath, configFile);
-        expect(successResult.resultType).toBe("success");
-        expect(successResult.configFileAbsolutePath).toBe(configFile);
-    });
-}); //# sourceMappingURL=config-loader.test.js.map

package/dist/esm/esm/esm/tsconfig-paths/lib/__tests__/data/match-path-data.d.js

@@ -1 +0,0 @@
-export { };