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

package/dist/cjs/@jest/pattern/src/__tests__/TestPathPatterns.test.js

@@ -0,0 +1,286 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _path = /*#__PURE__*/ _interop_require_wildcard(require("path"));
+const _TestPathPatterns = require("../TestPathPatterns");
+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;
+}
+const mockSep = jest.fn();
+const mockIsAbsolute = jest.fn();
+const mockRelative = jest.fn();
+jest.mock('path', ()=>{
+    const actualPath = jest.requireActual('path');
+    return {
+        ...actualPath,
+        isAbsolute (p) {
+            return mockIsAbsolute(p) || actualPath.isAbsolute(p);
+        },
+        relative (from, to) {
+            return mockRelative(from, to) || actualPath.relative(from, to);
+        },
+        get sep () {
+            return mockSep() || actualPath.sep;
+        }
+    };
+});
+const forcePosix = ()=>{
+    mockSep.mockReturnValue(_path.posix.sep);
+    mockIsAbsolute.mockImplementation(_path.posix.isAbsolute);
+    mockRelative.mockImplementation(_path.posix.relative);
+};
+const forceWindows = ()=>{
+    mockSep.mockReturnValue(_path.win32.sep);
+    mockIsAbsolute.mockImplementation(_path.win32.isAbsolute);
+    mockRelative.mockImplementation(_path.win32.relative);
+};
+beforeEach(()=>{
+    jest.resetAllMocks();
+    forcePosix();
+});
+const config = {
+    rootDir: ''
+};
+const testPathPatternsLikeTests = (makePatterns)=>{
+    describe('isSet', ()=>{
+        it('returns false if no patterns specified', ()=>{
+            const testPathPatterns = makePatterns([], config);
+            expect(testPathPatterns.isSet()).toBe(false);
+        });
+        it('returns true if patterns specified', ()=>{
+            const testPathPatterns = makePatterns([
+                'a'
+            ], config);
+            expect(testPathPatterns.isSet()).toBe(true);
+        });
+    });
+    describe('isValid', ()=>{
+        it('succeeds for empty patterns', ()=>{
+            const testPathPatterns = makePatterns([], config);
+            expect(testPathPatterns.isValid()).toBe(true);
+        });
+        it('succeeds for valid patterns', ()=>{
+            const testPathPatterns = makePatterns([
+                'abc+',
+                'z.*'
+            ], config);
+            expect(testPathPatterns.isValid()).toBe(true);
+        });
+        it('fails for at least one invalid pattern', ()=>{
+            const testPathPatterns = makePatterns([
+                'abc+',
+                '(',
+                'z.*'
+            ], config);
+            expect(testPathPatterns.isValid()).toBe(false);
+        });
+    });
+    describe('toPretty', ()=>{
+        it('renders a human-readable string', ()=>{
+            const testPathPatterns = makePatterns([
+                'a/b',
+                'c/d'
+            ], config);
+            expect(testPathPatterns.toPretty()).toMatchSnapshot();
+        });
+    });
+};
+describe('TestPathPatterns', ()=>{
+    testPathPatternsLikeTests((patterns, _)=>new _TestPathPatterns.TestPathPatterns(patterns));
+});
+describe('TestPathPatternsExecutor', ()=>{
+    const makeExecutor = (patterns, options)=>new _TestPathPatterns.TestPathPatternsExecutor(new _TestPathPatterns.TestPathPatterns(patterns), options);
+    testPathPatternsLikeTests(makeExecutor);
+    describe('isMatch', ()=>{
+        it('returns true with no patterns', ()=>{
+            const testPathPatterns = makeExecutor([], config);
+            expect(testPathPatterns.isMatch('/a/b')).toBe(true);
+        });
+        it('returns true for same path', ()=>{
+            const testPathPatterns = makeExecutor([
+                '/a/b'
+            ], config);
+            expect(testPathPatterns.isMatch('/a/b')).toBe(true);
+        });
+        it('returns true for same path with case insensitive', ()=>{
+            const testPathPatternsUpper = makeExecutor([
+                '/A/B'
+            ], config);
+            expect(testPathPatternsUpper.isMatch('/a/b')).toBe(true);
+            expect(testPathPatternsUpper.isMatch('/A/B')).toBe(true);
+            const testPathPatternsLower = makeExecutor([
+                '/a/b'
+            ], config);
+            expect(testPathPatternsLower.isMatch('/A/B')).toBe(true);
+            expect(testPathPatternsLower.isMatch('/a/b')).toBe(true);
+        });
+        it('returns true for contained path', ()=>{
+            const testPathPatterns = makeExecutor([
+                'b/c'
+            ], config);
+            expect(testPathPatterns.isMatch('/a/b/c/d')).toBe(true);
+        });
+        it('returns true for explicit relative path', ()=>{
+            const testPathPatterns = makeExecutor([
+                './b/c'
+            ], {
+                rootDir: '/a'
+            });
+            expect(testPathPatterns.isMatch('/a/b/c')).toBe(true);
+        });
+        it('returns true for explicit relative path for Windows with ./', ()=>{
+            forceWindows();
+            const testPathPatterns = makeExecutor([
+                './b/c'
+            ], {
+                rootDir: 'C:\\a'
+            });
+            expect(testPathPatterns.isMatch('C:\\a\\b\\c')).toBe(true);
+        });
+        it('returns true for explicit relative path for Windows with .\\', ()=>{
+            forceWindows();
+            const testPathPatterns = makeExecutor([
+                '.\\b\\c'
+            ], {
+                rootDir: 'C:\\a'
+            });
+            expect(testPathPatterns.isMatch('C:\\a\\b\\c')).toBe(true);
+        });
+        it('returns true for partial file match', ()=>{
+            const testPathPatterns = makeExecutor([
+                'aaa'
+            ], config);
+            expect(testPathPatterns.isMatch('/foo/..aaa..')).toBe(true);
+            expect(testPathPatterns.isMatch('/foo/..aaa')).toBe(true);
+            expect(testPathPatterns.isMatch('/foo/aaa..')).toBe(true);
+        });
+        it('returns true for path suffix', ()=>{
+            const testPathPatterns = makeExecutor([
+                'c/d'
+            ], config);
+            expect(testPathPatterns.isMatch('/a/b/c/d')).toBe(true);
+        });
+        it('returns true if regex matches', ()=>{
+            const testPathPatterns = makeExecutor([
+                'ab*c?'
+            ], config);
+            expect(testPathPatterns.isMatch('/foo/a')).toBe(true);
+            expect(testPathPatterns.isMatch('/foo/ab')).toBe(true);
+            expect(testPathPatterns.isMatch('/foo/abb')).toBe(true);
+            expect(testPathPatterns.isMatch('/foo/ac')).toBe(true);
+            expect(testPathPatterns.isMatch('/foo/abc')).toBe(true);
+            expect(testPathPatterns.isMatch('/foo/abbc')).toBe(true);
+            expect(testPathPatterns.isMatch('/foo/bc')).toBe(false);
+        });
+        it('returns true only if matches relative path', ()=>{
+            const rootDir = '/home/myuser/';
+            const testPathPatterns = makeExecutor([
+                'home'
+            ], {
+                rootDir
+            });
+            expect(testPathPatterns.isMatch(_path.relative(rootDir, '/home/myuser/LoginPage.js'))).toBe(false);
+            expect(testPathPatterns.isMatch(_path.relative(rootDir, '/home/myuser/HomePage.js'))).toBe(true);
+        });
+        it('matches absolute paths regardless of rootDir', ()=>{
+            forcePosix();
+            const testPathPatterns = makeExecutor([
+                '/a/b'
+            ], {
+                rootDir: '/foo/bar'
+            });
+            expect(testPathPatterns.isMatch('/a/b')).toBe(true);
+        });
+        it('matches absolute paths for Windows', ()=>{
+            forceWindows();
+            const testPathPatterns = makeExecutor([
+                'C:\\a\\b'
+            ], {
+                rootDir: 'C:\\foo\\bar'
+            });
+            expect(testPathPatterns.isMatch('C:\\a\\b')).toBe(true);
+        });
+        it('returns true if match any paths', ()=>{
+            const testPathPatterns = makeExecutor([
+                'a/b',
+                'c/d'
+            ], config);
+            expect(testPathPatterns.isMatch('/foo/a/b')).toBe(true);
+            expect(testPathPatterns.isMatch('/foo/c/d')).toBe(true);
+            expect(testPathPatterns.isMatch('/foo/a')).toBe(false);
+            expect(testPathPatterns.isMatch('/foo/b/c')).toBe(false);
+        });
+        it('does not normalize Windows paths on POSIX', ()=>{
+            forcePosix();
+            const testPathPatterns = makeExecutor([
+                'a\\z',
+                'a\\\\z'
+            ], config);
+            expect(testPathPatterns.isMatch('/foo/a/z')).toBe(false);
+        });
+        it('normalizes paths for Windows', ()=>{
+            forceWindows();
+            const testPathPatterns = makeExecutor([
+                'a/b'
+            ], config);
+            expect(testPathPatterns.isMatch('C:\\foo\\a\\b')).toBe(true);
+        });
+        it('matches absolute path with absPath', ()=>{
+            const pattern = '^/home/app/';
+            const rootDir = '/home/app';
+            const absolutePath = '/home/app/packages/';
+            const testPathPatterns = makeExecutor([
+                pattern
+            ], {
+                rootDir
+            });
+            const relativePath = _path.relative(rootDir, absolutePath);
+            expect(testPathPatterns.isMatch(relativePath)).toBe(false);
+            expect(testPathPatterns.isMatch(absolutePath)).toBe(true);
+        });
+    });
+});

package/dist/cjs/@swc/cli/lib/swc/__tests__/compile.test.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _core = require("@swc/core");
+const _compile = require("../compile");
+jest.mock("@swc/core");
+describe("compile", ()=>{
+    it("compile with sync transform", async ()=>{
+        const options = {};
+        await (0, _compile.compile)("test.ts", options, true, undefined);
+        expect(_core.transformFileSync).toHaveBeenCalledWith("test.ts", options);
+    });
+    it("compile with async transform", async ()=>{
+        const options = {};
+        await (0, _compile.compile)("test.ts", options, false, undefined);
+        expect(_core.transformFile).toHaveBeenCalledWith("test.ts", options);
+    });
+}); //# sourceMappingURL=compile.test.js.map

package/dist/cjs/@swc/cli/lib/swc/__tests__/options.test.js

@@ -0,0 +1,315 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _deepmerge = /*#__PURE__*/ _interopRequireDefault(require("deepmerge"));
+const _options = /*#__PURE__*/ _interopRequireWildcard(require("../options"));
+function _interopRequireDefault(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 _interopRequireWildcard(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;
+}
+const createDefaultResult = ()=>({
+        cliOptions: {
+            copyFiles: false,
+            deleteDirOnStart: false,
+            extensions: [
+                ".js",
+                ".jsx",
+                ".es6",
+                ".es",
+                ".mjs",
+                ".ts",
+                ".tsx",
+                ".cts",
+                ".mts"
+            ],
+            // @ts-expect-error
+            filename: undefined,
+            filenames: [
+                "src"
+            ],
+            ignore: [],
+            includeDotfiles: false,
+            only: [],
+            // @ts-expect-error
+            outDir: undefined,
+            // @ts-expect-error
+            outFile: undefined,
+            quiet: false,
+            sourceMapTarget: undefined,
+            sync: false,
+            watch: false
+        },
+        swcOptions: {
+            configFile: undefined,
+            jsc: {
+                parser: undefined,
+                transform: {}
+            },
+            sourceFileName: undefined,
+            sourceMaps: undefined,
+            sourceRoot: undefined,
+            swcrc: true
+        }
+    });
+describe("parserArgs", ()=>{
+    let defaultResult;
+    beforeEach(()=>{
+        defaultResult = createDefaultResult();
+        (0, _options.initProgram)();
+    });
+    it("minimal args returns default result", async ()=>{
+        const args = [
+            "node",
+            "/path/to/node_modules/swc-cli/bin/swc.js",
+            "src"
+        ];
+        const result = await (0, _options.default)(args);
+        expect(result).toEqual(defaultResult);
+    });
+    describe("errors", ()=>{
+        let mockExit;
+        let mockConsoleError;
+        beforeAll(()=>{
+            //@ts-expect-error
+            mockExit = jest.spyOn(process, "exit").mockImplementation(()=>{});
+            mockConsoleError = jest.spyOn(console, "error").mockImplementation(()=>{});
+        });
+        beforeEach(()=>{
+            mockExit.mockClear();
+            mockConsoleError.mockClear();
+        });
+        afterAll(()=>{
+            mockExit.mockRestore();
+            mockConsoleError.mockRestore();
+        });
+        it("exits without filenames", async ()=>{
+            const args = [
+                "node",
+                "/path/to/node_modules/swc-cli/bin/swc.js"
+            ];
+            await (0, _options.default)(args);
+            expect(mockExit).toHaveBeenCalledWith(2);
+            expect(mockConsoleError).toHaveBeenCalledTimes(2);
+        });
+        it("--watch exits without --out-dir", async ()=>{
+            const args = [
+                "node",
+                "/path/to/node_modules/swc-cli/bin/swc.js",
+                "src",
+                "--watch"
+            ];
+            await (0, _options.default)(args);
+            expect(mockExit).toHaveBeenCalledWith(2);
+            expect(mockConsoleError).toHaveBeenCalledTimes(2);
+        });
+        it("--watch exits without filenames", async ()=>{
+            const args = [
+                "node",
+                "/path/to/node_modules/swc-cli/bin/swc.js",
+                "--watch",
+                "--out-dir",
+                "esm"
+            ];
+            await (0, _options.default)(args);
+            expect(mockExit).toHaveBeenCalledWith(2);
+            expect(mockConsoleError).toHaveBeenCalledTimes(3);
+        });
+        it("--out-dir exits with conflicting -out-file", async ()=>{
+            const args = [
+                "node",
+                "/path/to/node_modules/swc-cli/bin/swc.js",
+                "src",
+                "--out-file",
+                "esm/index.js",
+                "--out-dir",
+                "esm"
+            ];
+            await (0, _options.default)(args);
+            expect(mockExit).toHaveBeenCalledWith(2);
+            expect(mockConsoleError).toHaveBeenCalledTimes(2);
+        });
+    });
+    describe("--source-maps", ()=>{
+        it("source maps is ambiguous", async ()=>{
+            const args = [
+                "node",
+                "/path/to/node_modules/swc-cli/bin/swc.js",
+                "src",
+                "--source-maps"
+            ];
+            const result = await (0, _options.default)(args);
+            const expectedOptions = (0, _deepmerge.default)(defaultResult, {
+                swcOptions: {
+                    sourceMaps: true
+                }
+            });
+            expect(result).toEqual(expectedOptions);
+        });
+        it("source maps true", async ()=>{
+            const args = [
+                "node",
+                "/path/to/node_modules/swc-cli/bin/swc.js",
+                "--source-maps",
+                "true",
+                "src"
+            ];
+            const result = await (0, _options.default)(args);
+            const expectedOptions = (0, _deepmerge.default)(defaultResult, {
+                swcOptions: {
+                    sourceMaps: true
+                }
+            });
+            expect(result).toEqual(expectedOptions);
+        });
+        it("source maps inline", async ()=>{
+            const args = [
+                "node",
+                "/path/to/node_modules/swc-cli/bin/swc.js",
+                "-s",
+                "inline",
+                "src"
+            ];
+            const result = await (0, _options.default)(args);
+            const expectedOptions = (0, _deepmerge.default)(defaultResult, {
+                swcOptions: {
+                    sourceMaps: "inline"
+                }
+            });
+            expect(result).toEqual(expectedOptions);
+        });
+    });
+    describe("--config", ()=>{
+        it("throws with no config", async ()=>{
+            const args = [
+                "node",
+                "/path/to/node_modules/swc-cli/bin/swc.js",
+                "src",
+                "-C"
+            ];
+            expect(()=>(0, _options.default)(args)).toThrow();
+        });
+        it("react development", async ()=>{
+            const args = [
+                "node",
+                "/path/to/node_modules/swc-cli/bin/swc.js",
+                "--config",
+                "jsc.transform.react.development=true",
+                "src"
+            ];
+            const result = await (0, _options.default)(args);
+            const expectedOptions = (0, _deepmerge.default)(defaultResult.swcOptions, {
+                jsc: {
+                    transform: {
+                        react: {
+                            development: true
+                        }
+                    }
+                }
+            });
+            expect(result.swcOptions).toEqual(expectedOptions);
+        });
+        it("react development and commonjs (two config options)", async ()=>{
+            const args = [
+                "node",
+                "/path/to/node_modules/swc-cli/bin/swc.js",
+                "--config",
+                "jsc.transform.react.development=true",
+                "-C",
+                "module.type=commonjs",
+                "src"
+            ];
+            const result = await (0, _options.default)(args);
+            const expectedOptions = (0, _deepmerge.default)(defaultResult.swcOptions, {
+                jsc: {
+                    transform: {
+                        react: {
+                            development: true
+                        }
+                    }
+                },
+                module: {
+                    type: "commonjs"
+                }
+            });
+            expect(result.swcOptions).toEqual(expectedOptions);
+        });
+        it("react development and commonjs (comma-separated)", async ()=>{
+            const args = [
+                "node",
+                "/path/to/node_modules/swc-cli/bin/swc.js",
+                "--config",
+                "jsc.transform.react.development=true,module.type=commonjs",
+                "src"
+            ];
+            const result = await (0, _options.default)(args);
+            const expectedOptions = (0, _deepmerge.default)(defaultResult.swcOptions, {
+                jsc: {
+                    transform: {
+                        react: {
+                            development: true
+                        }
+                    }
+                },
+                module: {
+                    type: "commonjs"
+                }
+            });
+            expect(result.swcOptions).toEqual(expectedOptions);
+        });
+        it("no equals sign", async ()=>{
+            const args = [
+                "node",
+                "/path/to/node_modules/swc-cli/bin/swc.js",
+                "--config",
+                "no_equals",
+                "src"
+            ];
+            const result = await (0, _options.default)(args);
+            const expectedOptions = (0, _deepmerge.default)(defaultResult.swcOptions, {
+                no_equals: true
+            });
+            expect(result.swcOptions).toEqual(expectedOptions);
+        });
+    });
+}); //# sourceMappingURL=options.test.js.map