@handlewithcare/react-prosemirror 3.1.0-tiptap.28 → 3.1.0-tiptap.30

package/dist/esm/esm/esm/cjs/esm/tsconfig-paths/src/__tests__/try-path.test.js

@@ -0,0 +1,218 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _trypath = require("../try-path");
+const _path = require("path");
+describe("mapping-entry", ()=>{
+    const abosolutePathMappings = [
+        {
+            pattern: "longest/pre/fix/*",
+            paths: [
+                (0, _path.join)("/absolute", "base", "url", "foo2", "bar")
+            ]
+        },
+        {
+            pattern: "pre/fix/*",
+            paths: [
+                (0, _path.join)("/absolute", "base", "url", "foo3")
+            ]
+        },
+        {
+            pattern: "*",
+            paths: [
+                (0, _path.join)("/absolute", "base", "url", "foo1")
+            ]
+        }
+    ];
+    const abosolutePathMappingsStarstWithSlash = [
+        {
+            pattern: "/opt/*",
+            paths: [
+                (0, _path.join)("/absolute", "src", "aws-layer")
+            ]
+        },
+        {
+            pattern: "*",
+            paths: [
+                (0, _path.join)("/absolute", "src")
+            ]
+        }
+    ];
+    it("should return no paths for relative requested module", ()=>{
+        const result = (0, _trypath.getPathsToTry)([
+            ".ts",
+            "tsx"
+        ], abosolutePathMappings, "./requested-module");
+        // assert.deepEqual(result, undefined);
+        expect(result).toBeUndefined();
+    });
+    it("should return no paths if no pattern match the requested module", ()=>{
+        const result = (0, _trypath.getPathsToTry)([
+            ".ts",
+            "tsx"
+        ], [
+            {
+                pattern: "longest/pre/fix/*",
+                paths: [
+                    (0, _path.join)("/absolute", "base", "url", "foo2", "bar")
+                ]
+            },
+            {
+                pattern: "pre/fix/*",
+                paths: [
+                    (0, _path.join)("/absolute", "base", "url", "foo3")
+                ]
+            }
+        ], "requested-module");
+        expect(result).toBeUndefined();
+    });
+    it("should get all paths that matches requested module", ()=>{
+        const result = (0, _trypath.getPathsToTry)([
+            ".ts",
+            ".tsx"
+        ], abosolutePathMappings, "longest/pre/fix/requested-module");
+        // assert.deepEqual(result, [
+        //   // "longest/pre/fix/*"
+        //   { type: "file", path: join("/absolute", "base", "url", "foo2", "bar") },
+        //   {
+        //     type: "extension",
+        //     path: join("/absolute", "base", "url", "foo2", "bar.ts"),
+        //   },
+        //   {
+        //     type: "extension",
+        //     path: join("/absolute", "base", "url", "foo2", "bar.tsx"),
+        //   },
+        //   {
+        //     type: "package",
+        //     path: join("/absolute", "base", "url", "foo2", "bar", "package.json"),
+        //   },
+        //   {
+        //     type: "index",
+        //     path: join("/absolute", "base", "url", "foo2", "bar", "index.ts"),
+        //   },
+        //   {
+        //     type: "index",
+        //     path: join("/absolute", "base", "url", "foo2", "bar", "index.tsx"),
+        //   },
+        //   // "*"
+        //   { type: "file", path: join("/absolute", "base", "url", "foo1") },
+        //   { type: "extension", path: join("/absolute", "base", "url", "foo1.ts") },
+        //   { type: "extension", path: join("/absolute", "base", "url", "foo1.tsx") },
+        //   {
+        //     type: "package",
+        //     path: join("/absolute", "base", "url", "foo1", "package.json"),
+        //   },
+        //   {
+        //     type: "index",
+        //     path: join("/absolute", "base", "url", "foo1", "index.ts"),
+        //   },
+        //   {
+        //     type: "index",
+        //     path: join("/absolute", "base", "url", "foo1", "index.tsx"),
+        //   },
+        // ]);
+        expect(result).toEqual([
+            // "longest/pre/fix/*"
+            {
+                type: "file",
+                path: (0, _path.join)("/absolute", "base", "url", "foo2", "bar")
+            },
+            {
+                type: "extension",
+                path: (0, _path.join)("/absolute", "base", "url", "foo2", "bar.ts")
+            },
+            {
+                type: "extension",
+                path: (0, _path.join)("/absolute", "base", "url", "foo2", "bar.tsx")
+            },
+            {
+                type: "package",
+                path: (0, _path.join)("/absolute", "base", "url", "foo2", "bar", "package.json")
+            },
+            {
+                type: "index",
+                path: (0, _path.join)("/absolute", "base", "url", "foo2", "bar", "index.ts")
+            },
+            {
+                type: "index",
+                path: (0, _path.join)("/absolute", "base", "url", "foo2", "bar", "index.tsx")
+            },
+            // "*"
+            {
+                type: "file",
+                path: (0, _path.join)("/absolute", "base", "url", "foo1")
+            },
+            {
+                type: "extension",
+                path: (0, _path.join)("/absolute", "base", "url", "foo1.ts")
+            },
+            {
+                type: "extension",
+                path: (0, _path.join)("/absolute", "base", "url", "foo1.tsx")
+            },
+            {
+                type: "package",
+                path: (0, _path.join)("/absolute", "base", "url", "foo1", "package.json")
+            },
+            {
+                type: "index",
+                path: (0, _path.join)("/absolute", "base", "url", "foo1", "index.ts")
+            },
+            {
+                type: "index",
+                path: (0, _path.join)("/absolute", "base", "url", "foo1", "index.tsx")
+            }
+        ]);
+    });
+    it("should resolve paths starting with a slash", ()=>{
+        const result = (0, _trypath.getPathsToTry)([
+            ".ts"
+        ], abosolutePathMappingsStarstWithSlash, "/opt/utils");
+        expect(result).toEqual([
+            // "opt/*"
+            {
+                path: (0, _path.join)("/absolute", "src", "aws-layer"),
+                type: "file"
+            },
+            {
+                path: (0, _path.join)("/absolute", "src", "aws-layer.ts"),
+                type: "extension"
+            },
+            {
+                path: (0, _path.join)("/absolute", "src", "aws-layer", "package.json"),
+                type: "package"
+            },
+            {
+                path: (0, _path.join)("/absolute", "src", "aws-layer", "index.ts"),
+                type: "index"
+            },
+            // "*"
+            {
+                path: (0, _path.join)("/absolute", "src"),
+                type: "file"
+            },
+            {
+                path: (0, _path.join)("/absolute", "src.ts"),
+                type: "extension"
+            },
+            {
+                path: (0, _path.join)("/absolute", "src", "package.json"),
+                type: "package"
+            },
+            {
+                path: (0, _path.join)("/absolute", "src", "index.ts"),
+                type: "index"
+            }
+        ]);
+    });
+}); // describe("match-star", () => {
+ //   it("should match star in last position", () => {
+ //     const result = matchStar("lib/*", "lib/mylib");
+ //     assert.equal(result, "mylib");
+ //   });
+ //   it("should match star in first position", () => {
+ //     const result = matchStar("*/lib", "mylib/lib");
+ //     assert.equal(result, "mylib");
+ //   });
+ // });

package/dist/esm/esm/esm/cjs/esm/tsconfig-paths/src/__tests__/tsconfig-loader.test.js

@@ -0,0 +1,300 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _tsconfigloader = require("../tsconfig-loader");
+const _path = require("path");
+describe("tsconfig-loader", ()=>{
+    it("should find tsconfig in cwd", ()=>{
+        const result = (0, _tsconfigloader.tsConfigLoader)({
+            cwd: "/foo/bar",
+            getEnv: (_)=>undefined,
+            loadSync: (cwd)=>{
+                return {
+                    tsConfigPath: `${cwd}/tsconfig.json`,
+                    baseUrl: "./",
+                    paths: {}
+                };
+            }
+        });
+        // assert.equal(result.tsConfigPath, "/foo/bar/tsconfig.json");
+        expect(result.tsConfigPath).toBe("/foo/bar/tsconfig.json");
+    });
+    it("should return loaderResult.tsConfigPath as undefined when not found", ()=>{
+        const result = (0, _tsconfigloader.tsConfigLoader)({
+            cwd: "/foo/bar",
+            getEnv: (_)=>undefined,
+            loadSync: (_)=>{
+                return {
+                    tsConfigPath: undefined,
+                    baseUrl: "./",
+                    paths: {}
+                };
+            }
+        });
+        // assert.isUndefined(result.tsConfigPath);
+        expect(result.tsConfigPath).toBeUndefined();
+    });
+    it("should use TS_NODE_PROJECT env if exists", ()=>{
+        const result = (0, _tsconfigloader.tsConfigLoader)({
+            cwd: "/foo/bar",
+            getEnv: (key)=>key === "TS_NODE_PROJECT" ? "/foo/baz" : undefined,
+            loadSync: (cwd, fileName)=>{
+                if (cwd === "/foo/bar" && fileName === "/foo/baz") {
+                    return {
+                        tsConfigPath: "/foo/baz/tsconfig.json",
+                        baseUrl: "./",
+                        paths: {}
+                    };
+                }
+                return {
+                    tsConfigPath: undefined,
+                    baseUrl: "./",
+                    paths: {}
+                };
+            }
+        });
+        // assert.equal(result.tsConfigPath, "/foo/baz/tsconfig.json");
+        expect(result.tsConfigPath).toBe("/foo/baz/tsconfig.json");
+    });
+    it("should use TS_NODE_BASEURL env if exists", ()=>{
+        const result = (0, _tsconfigloader.tsConfigLoader)({
+            cwd: "/foo/bar",
+            getEnv: (key)=>key === "TS_NODE_BASEURL" ? "SOME_BASEURL" : undefined,
+            loadSync: (_0, _1, baseUrl)=>{
+                return {
+                    tsConfigPath: undefined,
+                    baseUrl,
+                    paths: {}
+                };
+            }
+        });
+        // assert.equal(result.baseUrl, "SOME_BASEURL");
+        expect(result.baseUrl).toBe("SOME_BASEURL");
+    });
+    it("should not use TS_NODE_BASEURL env if it does not exist", ()=>{
+        const result = (0, _tsconfigloader.tsConfigLoader)({
+            cwd: "/foo/bar",
+            getEnv: (_)=>{
+                return undefined;
+            },
+            loadSync: (_0, _1, baseUrl)=>{
+                return {
+                    tsConfigPath: undefined,
+                    baseUrl,
+                    paths: {}
+                };
+            }
+        });
+        // assert.equal(result.baseUrl, undefined);
+        expect(result.baseUrl).toBeUndefined();
+    });
+});
+describe("walkForTsConfig", ()=>{
+    it("should find tsconfig in starting directory", ()=>{
+        const pathToTsconfig = (0, _path.join)("/root", "dir1", "tsconfig.json");
+        const res = (0, _tsconfigloader.walkForTsConfig)((0, _path.join)("/root", "dir1"), (path)=>path === pathToTsconfig);
+        // assert.equal(res, pathToTsconfig);
+        expect(res).toBe(pathToTsconfig);
+    });
+    it("should find tsconfig in parent directory", ()=>{
+        const pathToTsconfig = (0, _path.join)("/root", "tsconfig.json");
+        const res = (0, _tsconfigloader.walkForTsConfig)((0, _path.join)("/root", "dir1"), (path)=>path === pathToTsconfig);
+        // assert.equal(res, pathToTsconfig);
+        expect(res).toBe(pathToTsconfig);
+    });
+    it("should return undefined when reaching the top", ()=>{
+        const res = (0, _tsconfigloader.walkForTsConfig)((0, _path.join)("/root", "dir1", "kalle"), ()=>false);
+        // assert.equal(res, undefined);
+        expect(res).toBeUndefined();
+    });
+});
+describe("loadConfig", ()=>{
+    it("It should load a config", ()=>{
+        const config = {
+            compilerOptions: {
+                baseUrl: "hej"
+            }
+        };
+        const res = (0, _tsconfigloader.loadTsconfig)("/root/dir1/tsconfig.json", (path)=>path === "/root/dir1/tsconfig.json", (_)=>JSON.stringify(config));
+        // assert.deepEqual(res, config);
+        expect(res).toStrictEqual(config);
+    });
+    it("It should load a config with comments", ()=>{
+        const config = {
+            compilerOptions: {
+                baseUrl: "hej"
+            }
+        };
+        const res = (0, _tsconfigloader.loadTsconfig)("/root/dir1/tsconfig.json", (path)=>path === "/root/dir1/tsconfig.json", (_)=>`{
+          // my comment
+          "compilerOptions": { 
+            "baseUrl": "hej"
+          }
+        }`);
+        // assert.deepEqual(res, config);
+        expect(res).toStrictEqual(config);
+    });
+    it("It should load a config with trailing commas", ()=>{
+        const config = {
+            compilerOptions: {
+                baseUrl: "hej"
+            }
+        };
+        const res = (0, _tsconfigloader.loadTsconfig)("/root/dir1/tsconfig.json", (path)=>path === "/root/dir1/tsconfig.json", (_)=>`{
+          "compilerOptions": { 
+            "baseUrl": "hej",
+          },
+        }`);
+        // assert.deepEqual(res, config);
+        expect(res).toStrictEqual(config);
+    });
+    it("It should load a config with extends and overwrite all options", ()=>{
+        const firstConfig = {
+            extends: "../base-config.json",
+            compilerOptions: {
+                baseUrl: "kalle",
+                paths: {
+                    foo: [
+                        "bar2"
+                    ]
+                }
+            }
+        };
+        const firstConfigPath = (0, _path.join)("/root", "dir1", "tsconfig.json");
+        const baseConfig = {
+            compilerOptions: {
+                baseUrl: "olle",
+                paths: {
+                    foo: [
+                        "bar1"
+                    ]
+                },
+                strict: true
+            }
+        };
+        const baseConfigPath = (0, _path.join)("/root", "base-config.json");
+        const res = (0, _tsconfigloader.loadTsconfig)((0, _path.join)("/root", "dir1", "tsconfig.json"), (path)=>path === firstConfigPath || path === baseConfigPath, (path)=>{
+            if (path === firstConfigPath) {
+                return JSON.stringify(firstConfig);
+            }
+            if (path === baseConfigPath) {
+                return JSON.stringify(baseConfig);
+            }
+            return "";
+        });
+        // assert.deepEqual(res, {
+        //   extends: "../base-config.json",
+        //   compilerOptions: {
+        //     baseUrl: "kalle",
+        //     paths: { foo: ["bar2"] },
+        //     strict: true,
+        //   },
+        // });
+        expect(res).toEqual({
+            extends: "../base-config.json",
+            compilerOptions: {
+                baseUrl: "kalle",
+                paths: {
+                    foo: [
+                        "bar2"
+                    ]
+                },
+                strict: true
+            }
+        });
+    });
+    it("It should load a config with extends from node_modules and overwrite all options", ()=>{
+        const firstConfig = {
+            extends: "my-package/base-config.json",
+            compilerOptions: {
+                baseUrl: "kalle",
+                paths: {
+                    foo: [
+                        "bar2"
+                    ]
+                }
+            }
+        };
+        const firstConfigPath = (0, _path.join)("/root", "dir1", "tsconfig.json");
+        const baseConfig = {
+            compilerOptions: {
+                baseUrl: "olle",
+                paths: {
+                    foo: [
+                        "bar1"
+                    ]
+                },
+                strict: true
+            }
+        };
+        const baseConfigPath = (0, _path.join)("/root", "dir1", "node_modules", "my-package", "base-config.json");
+        const res = (0, _tsconfigloader.loadTsconfig)((0, _path.join)("/root", "dir1", "tsconfig.json"), (path)=>path === firstConfigPath || path === baseConfigPath, (path)=>{
+            if (path === firstConfigPath) {
+                return JSON.stringify(firstConfig);
+            }
+            if (path === baseConfigPath) {
+                return JSON.stringify(baseConfig);
+            }
+            return "";
+        });
+        // assert.deepEqual(res, {
+        //   extends: "my-package/base-config.json",
+        //   compilerOptions: {
+        //     baseUrl: "kalle",
+        //     paths: { foo: ["bar2"] },
+        //     strict: true,
+        //   },
+        // });
+        expect(res).toEqual({
+            extends: "my-package/base-config.json",
+            compilerOptions: {
+                baseUrl: "kalle",
+                paths: {
+                    foo: [
+                        "bar2"
+                    ]
+                },
+                strict: true
+            }
+        });
+    });
+    it("Should use baseUrl relative to location of extended tsconfig", ()=>{
+        const firstConfig = {
+            compilerOptions: {
+                baseUrl: "."
+            }
+        };
+        const firstConfigPath = (0, _path.join)("/root", "first-config.json");
+        const secondConfig = {
+            extends: "../first-config.json"
+        };
+        const secondConfigPath = (0, _path.join)("/root", "dir1", "second-config.json");
+        const thirdConfig = {
+            extends: "../second-config.json"
+        };
+        const thirdConfigPath = (0, _path.join)("/root", "dir1", "dir2", "third-config.json");
+        const res = (0, _tsconfigloader.loadTsconfig)((0, _path.join)("/root", "dir1", "dir2", "third-config.json"), (path)=>path === firstConfigPath || path === secondConfigPath || path === thirdConfigPath, (path)=>{
+            if (path === firstConfigPath) {
+                return JSON.stringify(firstConfig);
+            }
+            if (path === secondConfigPath) {
+                return JSON.stringify(secondConfig);
+            }
+            if (path === thirdConfigPath) {
+                return JSON.stringify(thirdConfig);
+            }
+            return "";
+        });
+        // assert.deepEqual(res, {
+        //   extends: "../second-config.json",
+        //   compilerOptions: { baseUrl: join("..", "..") },
+        // });
+        expect(res).toEqual({
+            extends: "../second-config.json",
+            compilerOptions: {
+                baseUrl: (0, _path.join)("..", "..")
+            }
+        });
+    });
+});

package/dist/esm/esm/esm/cjs/hooks/__tests__/useEditorEffect.test.js

@@ -0,0 +1,143 @@
+/* Copyright (c) The New York Times Company */ /* eslint-disable @typescript-eslint/no-empty-function */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _react = require("@testing-library/react");
+const _react1 = /*#__PURE__*/ _interop_require_default(require("react"));
+const _ReactEditorView = require("../../ReactEditorView.js");
+const _LayoutGroup = require("../../components/LayoutGroup.js");
+const _constants = require("../../constants.js");
+const _EditorContext = require("../../contexts/EditorContext.js");
+const _EditorStateContext = require("../../contexts/EditorStateContext.js");
+const _useEditorEffect = require("../useEditorEffect.js");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function TestComponent(param) {
+    let { effect, dependencies = [] } = param;
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    (0, _useEditorEffect.useEditorEffect)(effect, dependencies);
+    return null;
+}
+describe("useEditorEffect", ()=>{
+    it("should run the effect", ()=>{
+        const effect = jest.fn();
+        const editorState = _constants.EMPTY_STATE;
+        const editorView = new _ReactEditorView.ReactEditorView({
+            mount: document.createElement("div")
+        }, {
+            state: editorState
+        });
+        const registerEventListener = ()=>{};
+        const unregisterEventListener = ()=>{};
+        const flushSyncRef = {
+            current: true
+        };
+        (0, _react.render)(/*#__PURE__*/ _react1.default.createElement(_LayoutGroup.LayoutGroup, null, /*#__PURE__*/ _react1.default.createElement(_EditorContext.EditorContext.Provider, {
+            value: {
+                view: editorView,
+                cursorWrapper: null,
+                flushSyncRef,
+                registerEventListener,
+                unregisterEventListener,
+                isStatic: false
+            }
+        }, /*#__PURE__*/ _react1.default.createElement(_EditorStateContext.EditorStateContext.Provider, {
+            value: editorState
+        }, /*#__PURE__*/ _react1.default.createElement(TestComponent, {
+            effect: effect
+        })))));
+        expect(effect).toHaveBeenCalled();
+        expect(effect).toHaveBeenCalledWith(editorView);
+    });
+    it("should not re-run the effect if no dependencies change", ()=>{
+        const effect = jest.fn();
+        const editorState = _constants.EMPTY_STATE;
+        const editorView = new _ReactEditorView.ReactEditorView({
+            mount: document.createElement("div")
+        }, {
+            state: editorState
+        });
+        const registerEventListener = ()=>{};
+        const unregisterEventListener = ()=>{};
+        const contextValue = {
+            view: editorView,
+            cursorWrapper: null,
+            flushSyncRef: {
+                current: true
+            },
+            registerEventListener,
+            unregisterEventListener,
+            isStatic: false
+        };
+        const { rerender } = (0, _react.render)(/*#__PURE__*/ _react1.default.createElement(_LayoutGroup.LayoutGroup, null, /*#__PURE__*/ _react1.default.createElement(_EditorContext.EditorContext.Provider, {
+            value: contextValue
+        }, /*#__PURE__*/ _react1.default.createElement(_EditorStateContext.EditorStateContext.Provider, {
+            value: editorState
+        }, /*#__PURE__*/ _react1.default.createElement(TestComponent, {
+            effect: effect,
+            dependencies: []
+        })), " ")));
+        rerender(/*#__PURE__*/ _react1.default.createElement(_LayoutGroup.LayoutGroup, null, /*#__PURE__*/ _react1.default.createElement(_EditorContext.EditorContext.Provider, {
+            value: contextValue
+        }, /*#__PURE__*/ _react1.default.createElement(_EditorStateContext.EditorStateContext.Provider, {
+            value: editorState
+        }, /*#__PURE__*/ _react1.default.createElement(TestComponent, {
+            effect: effect,
+            dependencies: []
+        })))));
+        expect(effect).toHaveBeenCalledTimes(1);
+    });
+    it("should re-run the effect if dependencies change", ()=>{
+        const effect = jest.fn();
+        const editorState = _constants.EMPTY_STATE;
+        const editorView = new _ReactEditorView.ReactEditorView({
+            mount: document.createElement("div")
+        }, {
+            state: editorState
+        });
+        const registerEventListener = ()=>{};
+        const unregisterEventListener = ()=>{};
+        const { rerender } = (0, _react.render)(/*#__PURE__*/ _react1.default.createElement(_LayoutGroup.LayoutGroup, null, /*#__PURE__*/ _react1.default.createElement(_EditorContext.EditorContext.Provider, {
+            value: {
+                view: editorView,
+                cursorWrapper: null,
+                flushSyncRef: {
+                    current: true
+                },
+                registerEventListener,
+                unregisterEventListener,
+                isStatic: false
+            }
+        }, /*#__PURE__*/ _react1.default.createElement(_EditorStateContext.EditorStateContext.Provider, {
+            value: editorState
+        }, /*#__PURE__*/ _react1.default.createElement(TestComponent, {
+            effect: effect,
+            dependencies: [
+                "one"
+            ]
+        })))));
+        rerender(/*#__PURE__*/ _react1.default.createElement(_LayoutGroup.LayoutGroup, null, /*#__PURE__*/ _react1.default.createElement(_EditorContext.EditorContext.Provider, {
+            value: {
+                view: editorView,
+                registerEventListener,
+                unregisterEventListener,
+                cursorWrapper: null,
+                flushSyncRef: {
+                    current: true
+                },
+                isStatic: false
+            }
+        }, /*#__PURE__*/ _react1.default.createElement(_EditorStateContext.EditorStateContext.Provider, {
+            value: editorState
+        }, /*#__PURE__*/ _react1.default.createElement(TestComponent, {
+            effect: effect,
+            dependencies: [
+                "two"
+            ]
+        })))));
+        expect(effect).toHaveBeenCalledTimes(2);
+    });
+});