@devrev/airsync-sdk 2.0.0-beta.3 → 2.0.0-beta.5

package/dist/multithreading/spawn/spawn.test.js

@@ -1,232 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const events_1 = require("events");
-const constants_1 = require("../../common/constants");
-const extraction_1 = require("../../types/extraction");
-const workers_1 = require("../../types/workers");
-const test_utils_1 = require("../../common/test-utils");
-// ---------------------------------------------------------------------------
-// Mocks
-// ---------------------------------------------------------------------------
-jest.mock('../create-worker', () => ({
-    createWorker: jest.fn(),
-}));
-jest.mock('../../common/control-protocol', () => ({
-    emit: jest.fn().mockResolvedValue({}),
-}));
-jest.mock('../../logger/logger', () => ({
-    Logger: jest.fn().mockImplementation(() => ({
-        log: jest.fn(),
-        warn: jest.fn(),
-        error: jest.fn(),
-        info: jest.fn(),
-        logFn: jest.fn(),
-    })),
-    serializeError: jest.fn((e) => String(e)),
-}));
-jest.mock('../../common/helpers', () => ({
-    getLibraryVersion: jest.fn().mockReturnValue('1.0.0-test'),
-    getMemoryUsage: jest.fn().mockReturnValue({
-        formattedMessage: 'Memory: RSS 100/512MB (19.53%) [...]',
-        rssUsedMB: '100.00',
-        rssUsedPercent: '19.53%',
-        heapUsedPercent: '30.00%',
-        externalMB: '10.00',
-        arrayBuffersMB: '5.00',
-    }),
-    sleep: jest.fn(),
-    truncateFilename: jest.fn((f) => f),
-    truncateMessage: jest.fn((m) => m),
-}));
-// ---------------------------------------------------------------------------
-// Imports after mocks
-// ---------------------------------------------------------------------------
-const spawn_1 = require("./spawn");
-const create_worker_1 = require("../create-worker");
-const control_protocol_1 = require("../../common/control-protocol");
-const helpers_1 = require("../../common/helpers");
-// ---------------------------------------------------------------------------
-// Factory for a fake worker (EventEmitter with postMessage + terminate)
-// ---------------------------------------------------------------------------
-function makeWorker() {
-    const w = new events_1.EventEmitter();
-    w.postMessage = jest.fn();
-    w.terminate = jest.fn().mockResolvedValue(0);
-    return w;
-}
-// ---------------------------------------------------------------------------
-// Helper: instantiate Spawn directly, injecting a mock logger via console swap
-// ---------------------------------------------------------------------------
-function buildSpawn(overrides) {
-    var _a;
-    const event = (0, test_utils_1.createMockEvent)('http://localhost:0', {
-        payload: { event_type: extraction_1.EventType.StartExtractingData },
-    });
-    const mockLogger = {
-        log: jest.fn(),
-        warn: jest.fn(),
-        error: jest.fn(),
-        info: jest.fn(),
-        logFn: jest.fn(),
-    };
-    const originalConsole = console;
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    global.console = mockLogger;
-    const s = new spawn_1.Spawn({
-        event,
-        worker: overrides.worker,
-        options: overrides.options,
-        resolve: (_a = overrides.resolve) !== null && _a !== void 0 ? _a : jest.fn(),
-        originalConsole: originalConsole,
-    });
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    global.console = originalConsole;
-    return s;
-}
-// ---------------------------------------------------------------------------
-// spawn() factory tests
-// ---------------------------------------------------------------------------
-describe('spawn() factory', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-        jest.useFakeTimers({ legacyFakeTimers: true });
-    });
-    afterEach(() => {
-        jest.useRealTimers();
-    });
-    it('should emit a no-script event and NOT spawn a worker for an unknown event type', async () => {
-        // Arrange
-        const event = (0, test_utils_1.createMockEvent)('http://localhost:0', {
-            payload: { event_type: extraction_1.EventType.UnknownEventType },
-        });
-        // Act
-        await (0, spawn_1.spawn)({ event, initialState: {} });
-        // Assert: no worker process should be started, but the platform should
-        // still receive a terminal event (so the run doesn't hang).
-        expect(create_worker_1.createWorker).not.toHaveBeenCalled();
-        expect(control_protocol_1.emit).toHaveBeenCalledWith(expect.objectContaining({ event, eventType: expect.any(String) }));
-    });
-    it('should reject the returned promise when createWorker throws', async () => {
-        // Arrange
-        create_worker_1.createWorker.mockRejectedValue(new Error('worker boom'));
-        const event = (0, test_utils_1.createMockEvent)('http://localhost:0', {
-            payload: { event_type: extraction_1.EventType.StartExtractingData },
-        });
-        // Act & Assert
-        await expect((0, spawn_1.spawn)({
-            event,
-            initialState: {},
-            baseWorkerPath: '/fake',
-            options: {
-                workerPathOverrides: {
-                    [extraction_1.EventType.StartExtractingData]: '/path.js',
-                },
-            },
-        })).rejects.toThrow('worker boom');
-    });
-});
-// ---------------------------------------------------------------------------
-// Spawn class — lifecycle tests
-// ---------------------------------------------------------------------------
-describe('Spawn class', () => {
-    let worker;
-    let resolveMock;
-    beforeEach(() => {
-        jest.clearAllMocks();
-        jest.useFakeTimers({ legacyFakeTimers: true });
-        worker = makeWorker();
-        resolveMock = jest.fn();
-    });
-    afterEach(() => {
-        jest.useRealTimers();
-    });
-    // -------------------------------------------------------------------------
-    // WorkerMessageFailed captured and propagated in error emit
-    // -------------------------------------------------------------------------
-    it('should include the WorkerMessageFailed reason in the error event emitted to the platform', async () => {
-        // Arrange
-        buildSpawn({ worker, resolve: resolveMock });
-        // Act
-        worker.emit(workers_1.WorkerEvent.WorkerMessage, {
-            subject: workers_1.WorkerMessageSubject.WorkerMessageFailed,
-            payload: { message: 'connector exploded' },
-        });
-        worker.emit(workers_1.WorkerEvent.WorkerExit, 1);
-        await Promise.resolve();
-        await Promise.resolve();
-        // Assert: the platform receives an error event whose message contains
-        // the reason sent by the worker — this is what operators see in the run log.
-        expect(control_protocol_1.emit).toHaveBeenCalledWith(expect.objectContaining({
-            data: expect.objectContaining({
-                error: expect.objectContaining({
-                    message: expect.stringContaining('connector exploded'),
-                }),
-            }),
-        }));
-        expect(resolveMock).toHaveBeenCalled();
-    });
-    it('should emit a data extraction error when the worker exits without ever emitting', async () => {
-        // Arrange
-        buildSpawn({ worker, resolve: resolveMock });
-        // Act
-        worker.emit(workers_1.WorkerEvent.WorkerExit, 1);
-        await Promise.resolve();
-        await Promise.resolve();
-        // Assert: a silent worker exit must surface a DataExtractionError to the
-        // platform with a non-empty message. The event type is the upstream
-        // contract; the exact message wording is implementation detail.
-        expect(control_protocol_1.emit).toHaveBeenCalledTimes(1);
-        const [emitted] = control_protocol_1.emit.mock.calls[0];
-        expect(emitted.eventType).toBe(extraction_1.ExtractorEventType.DataExtractionError);
-        expect(emitted.data.error.message).toEqual(expect.any(String));
-        expect(emitted.data.error.message.length).toBeGreaterThan(0);
-        expect(resolveMock).toHaveBeenCalled();
-    });
-    // Soft-timeout and hard-timeout timer behavior is covered end-to-end by
-    // src/tests/timeout-handling/ (real workers, real timers). Unit tests with
-    // fake timers only re-asserted the mocked setTimeout call and gave no signal.
-    // -------------------------------------------------------------------------
-    // Memory monitoring — error clears the interval
-    // -------------------------------------------------------------------------
-    it('should clear the memory monitoring interval when getMemoryUsage throws to prevent repeated crashes', async () => {
-        // Arrange
-        helpers_1.getMemoryUsage.mockImplementation(() => {
-            throw new Error('OOM');
-        });
-        const clearIntervalSpy = jest.spyOn(global, 'clearInterval');
-        buildSpawn({ worker, resolve: resolveMock });
-        // Act
-        jest.advanceTimersByTime(30001); // MEMORY_LOG_INTERVAL = 30 s
-        await Promise.resolve();
-        // Assert
-        expect(clearIntervalSpy).toHaveBeenCalled();
-    });
-    // -------------------------------------------------------------------------
-    // Soft-timeout race: worker emits AFTER softTimeoutSent — no double-emit
-    // -------------------------------------------------------------------------
-    it('should NOT emit an error when the worker successfully emits just after receiving the soft-timeout signal', async () => {
-        // Arrange
-        buildSpawn({ worker, resolve: resolveMock });
-        // Act: trigger soft timeout — sends WorkerMessageExit to the worker
-        jest.advanceTimersByTime(constants_1.DEFAULT_LAMBDA_TIMEOUT + 1);
-        await Promise.resolve();
-        // Confirm the soft-timeout path actually fired — guards against a silent
-        // pass if the timeout constant changes and the timer never runs.
-        expect(worker.postMessage).toHaveBeenCalledWith(expect.objectContaining({
-            subject: workers_1.WorkerMessageSubject.WorkerMessageExit,
-        }));
-        // Worker responds: emits its event successfully, then exits normally
-        worker.emit(workers_1.WorkerEvent.WorkerMessage, {
-            subject: workers_1.WorkerMessageSubject.WorkerMessageEmitted,
-        });
-        worker.emit(workers_1.WorkerEvent.WorkerExit, 0);
-        // The exit handler defers via setImmediate when softTimeoutSent=true
-        jest.runAllImmediates();
-        await Promise.resolve();
-        await Promise.resolve();
-        // Assert: no error should reach the platform — the worker completed its job
-        const errorEmits = control_protocol_1.emit.mock.calls.filter((call) => { var _a, _b; return (_b = (_a = call[0]) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.error; });
-        expect(errorEmits).toHaveLength(0);
-        expect(resolveMock).toHaveBeenCalled();
-    });
-});

package/dist/repo/repo.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=repo.test.d.ts.map

package/dist/repo/repo.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"repo.test.d.ts","sourceRoot":"","sources":["../../src/repo/repo.test.ts"],"names":[],"mappings":""}

package/dist/repo/repo.test.js

@@ -1,184 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const constants_1 = require("../common/constants");
-const test_helpers_1 = require("../tests/test-helpers");
-const jest_setup_1 = require("../tests/jest.setup");
-const test_utils_1 = require("../common/test-utils");
-const types_1 = require("../types");
-const repo_1 = require("./repo");
-jest.mock('../tests/test-helpers', () => (Object.assign(Object.assign({}, jest.requireActual('../tests/test-helpers')), { normalizeItem: jest.fn() })));
-describe(repo_1.Repo.name, () => {
-    let repo;
-    let normalize;
-    beforeEach(() => {
-        normalize = jest.fn();
-        repo = new repo_1.Repo({
-            event: (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
-                payload: { event_type: types_1.EventType.StartExtractingData },
-            }),
-            itemType: 'test_item_type',
-            normalize,
-            onUpload: jest.fn(),
-        });
-    });
-    afterEach(() => {
-        jest.clearAllMocks();
-    });
-    it('should normalize and push items when array contains items', async () => {
-        // Arrange
-        const items = (0, test_helpers_1.createItems)(10);
-        // Act
-        await repo.push(items);
-        // Assert
-        expect(normalize).toHaveBeenCalledTimes(10);
-        const normalizedItems = items.map((item) => (0, test_helpers_1.normalizeItem)(item));
-        expect(repo.getItems()).toEqual(normalizedItems);
-    });
-    it('should not normalize items when normalize function is not provided', async () => {
-        // Arrange
-        repo = new repo_1.Repo({
-            event: (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
-                payload: { event_type: types_1.EventType.StartExtractingData },
-            }),
-            itemType: 'test_item_type',
-            onUpload: jest.fn(),
-            options: {},
-        });
-        const items = (0, test_helpers_1.createItems)(10);
-        // Act
-        await repo.push(items);
-        // Assert
-        expect(normalize).not.toHaveBeenCalled();
-    });
-    it('[edge] should not push items when items array is empty', async () => {
-        // Act
-        await repo.push([]);
-        // Assert
-        expect(repo.getItems()).toEqual([]);
-    });
-    it('should not normalize items when item type is external_domain_metadata', async () => {
-        // Arrange
-        repo = new repo_1.Repo({
-            event: (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
-                payload: { event_type: types_1.EventType.StartExtractingData },
-            }),
-            itemType: constants_1.AirSyncDefaultItemTypes.EXTERNAL_DOMAIN_METADATA,
-            normalize,
-            onUpload: jest.fn(),
-            options: {},
-        });
-        const items = (0, test_helpers_1.createItems)(10);
-        // Act
-        await repo.push(items);
-        // Assert
-        expect(normalize).not.toHaveBeenCalled();
-    });
-    it('should not normalize items when item type is ssor_attachment', async () => {
-        // Arrange
-        repo = new repo_1.Repo({
-            event: (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
-                payload: { event_type: types_1.EventType.StartExtractingData },
-            }),
-            itemType: constants_1.SSOR_ATTACHMENT,
-            normalize,
-            onUpload: jest.fn(),
-            options: {},
-        });
-        const items = (0, test_helpers_1.createItems)(10);
-        // Act
-        await repo.push(items);
-        // Assert
-        expect(normalize).not.toHaveBeenCalled();
-    });
-    it('should leave 5 items in the items array after pushing 2005 items with batch size of 2000', async () => {
-        // Arrange
-        const items = (0, test_helpers_1.createItems)(2005);
-        // Act
-        await repo.push(items);
-        // Assert
-        expect(repo.getItems().length).toBe(5);
-    });
-    it('should normalize all items when pushing 4005 items with batch size of 2000', async () => {
-        // Arrange
-        const items = (0, test_helpers_1.createItems)(4005);
-        // Act
-        await repo.push(items);
-        // Assert
-        expect(normalize).toHaveBeenCalledTimes(4005);
-    });
-    it('should upload 2 batches when pushing 4005 items with batch size of 2000', async () => {
-        // Arrange
-        const uploadSpy = jest.spyOn(repo, 'upload');
-        const items = (0, test_helpers_1.createItems)(4005);
-        // Act
-        await repo.push(items);
-        // Assert
-        expect(uploadSpy).toHaveBeenCalledTimes(2);
-        uploadSpy.mockRestore();
-    });
-    it('should leave 5 items in array after pushing 4005 items with batch size of 2000', async () => {
-        // Arrange
-        const items = (0, test_helpers_1.createItems)(4005);
-        // Act
-        await repo.push(items);
-        // Assert
-        expect(repo.getItems().length).toBe(5);
-    });
-    describe('should take batch size into account', () => {
-        beforeEach(() => {
-            repo = new repo_1.Repo({
-                event: (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
-                    payload: { event_type: types_1.EventType.StartExtractingData },
-                }),
-                itemType: 'test_item_type',
-                normalize,
-                onUpload: jest.fn(),
-                options: {
-                    batchSize: 50,
-                },
-            });
-        });
-        it('should empty the items array after pushing 50 items with batch size of 50', async () => {
-            // Arrange
-            const items = (0, test_helpers_1.createItems)(50);
-            // Act
-            await repo.push(items);
-            // Assert
-            expect(repo.getItems()).toEqual([]);
-        });
-        it('should leave 5 items in the items array after pushing 205 items with batch size of 50', async () => {
-            // Arrange
-            const items = (0, test_helpers_1.createItems)(205);
-            // Act
-            await repo.push(items);
-            // Assert
-            expect(repo.getItems().length).toBe(5);
-        });
-        it('should normalize all items when pushing 205 items with batch size of 50', async () => {
-            // Arrange
-            const items = (0, test_helpers_1.createItems)(205);
-            // Act
-            await repo.push(items);
-            // Assert
-            expect(normalize).toHaveBeenCalledTimes(205);
-        });
-        it('should upload 4 batches when pushing 205 items with batch size of 50', async () => {
-            // Arrange
-            const uploadSpy = jest.spyOn(repo, 'upload');
-            const items = (0, test_helpers_1.createItems)(205);
-            // Act
-            await repo.push(items);
-            // Assert
-            expect(uploadSpy).toHaveBeenCalledTimes(4);
-            uploadSpy.mockRestore();
-        });
-        it('should leave 5 items in array after pushing 205 items with batch size of 50', async () => {
-            // Arrange
-            const items = (0, test_helpers_1.createItems)(205);
-            // Act
-            await repo.push(items);
-            // Assert
-            expect(repo.getItems().length).toBe(5);
-        });
-    });
-});

package/dist/state/state.extract-window.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=state.extract-window.test.d.ts.map

package/dist/state/state.extract-window.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"state.extract-window.test.d.ts","sourceRoot":"","sources":["../../src/state/state.extract-window.test.ts"],"names":[],"mappings":""}

package/dist/state/state.extract-window.test.js

@@ -1,163 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const jest_setup_1 = require("../tests/jest.setup");
-const test_utils_1 = require("../common/test-utils");
-const extraction_1 = require("../types/extraction");
-const extraction_state_1 = require("./extraction-state");
-describe('State — extraction window validation', () => {
-    let fetchStateSpy;
-    let processExitSpy;
-    beforeEach(() => {
-        jest.clearAllMocks();
-        jest.restoreAllMocks();
-        fetchStateSpy = jest.spyOn(extraction_state_1.ExtractionState.prototype, 'fetchState');
-        processExitSpy = jest.spyOn(process, 'exit').mockImplementation(() => {
-            throw new Error('process.exit called');
-        });
-    });
-    describe('Enhanced Control Protocol - extraction window validation', () => {
-        it('should exit the process if extract_from >= extract_to', async () => {
-            // Arrange: start is after end (inverted window)
-            const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
-                payload: {
-                    event_type: extraction_1.EventType.StartExtractingMetadata,
-                    event_context: {
-                        extraction_start_time: {
-                            type: extraction_1.TimeValueType.ABSOLUTE_TIME,
-                            value: '2025-06-01T00:00:00Z',
-                        },
-                        extraction_end_time: {
-                            type: extraction_1.TimeValueType.ABSOLUTE_TIME,
-                            value: '2024-01-01T00:00:00Z',
-                        },
-                    },
-                },
-            });
-            const stringifiedState = JSON.stringify({
-                snapInVersionId: 'test_snap_in_version_id',
-            });
-            fetchStateSpy.mockResolvedValue({ state: stringifiedState });
-            // Act & Assert
-            await expect((0, extraction_state_1.createExtractionState)({
-                event,
-                initialState: {},
-                initialDomainMapping: {},
-            })).rejects.toThrow('process.exit called');
-            expect(processExitSpy).toHaveBeenCalledWith(1);
-        });
-        it('should exit the process if extract_from equals extract_to', async () => {
-            // Arrange: start equals end (zero-width window)
-            const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
-                payload: {
-                    event_type: extraction_1.EventType.StartExtractingMetadata,
-                    event_context: {
-                        extraction_start_time: {
-                            type: extraction_1.TimeValueType.ABSOLUTE_TIME,
-                            value: '2024-06-01T00:00:00Z',
-                        },
-                        extraction_end_time: {
-                            type: extraction_1.TimeValueType.ABSOLUTE_TIME,
-                            value: '2024-06-01T00:00:00Z',
-                        },
-                    },
-                },
-            });
-            const stringifiedState = JSON.stringify({
-                snapInVersionId: 'test_snap_in_version_id',
-            });
-            fetchStateSpy.mockResolvedValue({ state: stringifiedState });
-            // Act & Assert
-            await expect((0, extraction_state_1.createExtractionState)({
-                event,
-                initialState: {},
-                initialDomainMapping: {},
-            })).rejects.toThrow('process.exit called');
-            expect(processExitSpy).toHaveBeenCalledWith(1);
-        });
-        it('should not exit when extract_from < extract_to', async () => {
-            // Arrange: valid window
-            const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
-                payload: {
-                    event_type: extraction_1.EventType.StartExtractingMetadata,
-                    event_context: {
-                        extraction_start_time: {
-                            type: extraction_1.TimeValueType.ABSOLUTE_TIME,
-                            value: '2024-01-01T00:00:00Z',
-                        },
-                        extraction_end_time: {
-                            type: extraction_1.TimeValueType.ABSOLUTE_TIME,
-                            value: '2025-06-01T00:00:00Z',
-                        },
-                    },
-                },
-            });
-            const stringifiedState = JSON.stringify({
-                snapInVersionId: 'test_snap_in_version_id',
-            });
-            fetchStateSpy.mockResolvedValue({ state: stringifiedState });
-            // Act
-            await (0, extraction_state_1.createExtractionState)({
-                event,
-                initialState: {},
-                initialDomainMapping: {},
-            });
-            // Assert: process.exit should NOT have been called
-            expect(processExitSpy).not.toHaveBeenCalled();
-        });
-        it('should not validate when only extract_from is set', async () => {
-            // Arrange: only start, no end
-            const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
-                payload: {
-                    event_type: extraction_1.EventType.StartExtractingMetadata,
-                    event_context: {
-                        extraction_start_time: {
-                            type: extraction_1.TimeValueType.ABSOLUTE_TIME,
-                            value: '2024-01-01T00:00:00Z',
-                        },
-                    },
-                },
-            });
-            const stringifiedState = JSON.stringify({
-                snapInVersionId: 'test_snap_in_version_id',
-            });
-            fetchStateSpy.mockResolvedValue({ state: stringifiedState });
-            // Act
-            await (0, extraction_state_1.createExtractionState)({
-                event,
-                initialState: {},
-                initialDomainMapping: {},
-            });
-            // Assert: process.exit should NOT have been called
-            expect(processExitSpy).not.toHaveBeenCalled();
-        });
-        it('should not exit when extract_from is UNBOUNDED and extract_to is a real timestamp', async () => {
-            // Arrange: UNBOUNDED start (epoch) with a real ABSOLUTE end timestamp
-            const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
-                payload: {
-                    event_type: extraction_1.EventType.StartExtractingMetadata,
-                    event_context: {
-                        extraction_start_time: {
-                            type: extraction_1.TimeValueType.UNBOUNDED,
-                        },
-                        extraction_end_time: {
-                            type: extraction_1.TimeValueType.ABSOLUTE_TIME,
-                            value: '2025-06-01T00:00:00Z',
-                        },
-                    },
-                },
-            });
-            const stringifiedState = JSON.stringify({
-                snapInVersionId: 'test_snap_in_version_id',
-            });
-            fetchStateSpy.mockResolvedValue({ state: stringifiedState });
-            // Act
-            await (0, extraction_state_1.createExtractionState)({
-                event,
-                initialState: {},
-                initialDomainMapping: {},
-            });
-            // Assert: process.exit should NOT have been called
-            expect(processExitSpy).not.toHaveBeenCalled();
-        });
-    });
-});

package/dist/state/state.pending-boundaries.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=state.pending-boundaries.test.d.ts.map

package/dist/state/state.pending-boundaries.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"state.pending-boundaries.test.d.ts","sourceRoot":"","sources":["../../src/state/state.pending-boundaries.test.ts"],"names":[],"mappings":""}