@luvio/adapter-test-library 0.142.2 → 0.142.3

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@luvio/adapter-test-library",
-    "version": "0.142.2",
+    "version": "0.142.3",
     "description": "Test library for luvio adapters",
     "repository": {
         "type": "git",
@@ -8,9 +8,16 @@
         "directory": "packages/@luvio/adapter-test-library"
     },
     "license": "MIT",
-    "main": "dist/umd/es2018/test-library.js",
-    "module": "dist/es/es2018/test-library.js",
-    "types": "dist/es/es2018/types/main.d.ts",
+    "exports": {
+        "types": "./dist/types/main.d.ts",
+        "import": "./dist/test-library.js",
+        "default": "./dist/test-library.js"
+    },
+    "module": "dist/test-library.js",
+    "types": "dist/types/main.d.ts",
+    "files": [
+        "dist/"
+    ],
     "scripts": {
         "build": "rollup --bundleConfigAsCjs --config rollup.config.js",
         "clean": "rm -rf dist",
@@ -21,8 +28,8 @@
         "sinon": "^14.0.0"
     },
     "devDependencies": {
-        "@luvio/engine": "^0.142.2",
-        "@luvio/environments": "^0.142.2",
+        "@luvio/engine": "^0.142.3",
+        "@luvio/environments": "^0.142.3",
         "@types/sinon": "^7.5.2"
     },
     "volta": {

package/babel.config.js

@@ -1 +0,0 @@
-module.exports = require('../../../babel.config');

package/dist/umd/es2018/test-library.js

@@ -1,600 +0,0 @@
-(function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('sinon'), require('@luvio/engine')) :
-    typeof define === 'function' && define.amd ? define(['exports', 'sinon', '@luvio/engine'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.luvioAdapterTestLibrary = {}, global.sinon, global.engine));
-})(this, (function (exports, sinon, engine) { 'use strict';
-
-    function isImmutable(value) {
-        return !doesThrow(() => {
-            // if verifyImmutable does not throw then the object is immutable
-            verifyImmutable(value, '$');
-        });
-    }
-    function verifyImmutable(value, path) {
-        if (typeof value !== 'object' || value === null) {
-            return;
-        }
-        if (Array.isArray(value)) {
-            if (doesThrow(() => {
-                const len = value.length;
-                value.push('__test');
-                if (len === value.length) {
-                    throw new Error('IE11 does not throw when mutating a frozen object');
-                }
-            }) === false) {
-                throw new Error(`Unexpected mutable property found at ${path}: Array is extensible!`);
-            }
-            value.forEach((item, index) => {
-                verifyImmutable(item, `${path}.${index}`);
-            });
-            return;
-        }
-        if (doesThrow(() => {
-            value['__test_____'] = true;
-            if (value['__test_____'] !== true) {
-                throw new Error('IE11 does not throw when mutating a frozen object');
-            }
-        }) === false) {
-            throw new Error(`Unexpected mutable property found at ${path}: Object is extensible!`);
-        }
-        Object.keys(value).forEach((key) => {
-            if (doesThrow(() => {
-                const old = value[key];
-                value[key] = '_______foo';
-                if (value[key] === old) {
-                    throw new Error('IE11 does not throw when mutating a frozen object');
-                }
-            }) === false) {
-                throw new Error(`Unexpected mutable property found at ${path}: "${path}.${key}" is mutable!`);
-            }
-            verifyImmutable(value[key], `${path}.${key}`);
-        });
-    }
-
-    /**
-     * Clone an object
-     *
-     * @param {object} data The object to clone
-     * @returns {object} The cloned object
-     */
-    function clone(data) {
-        if (data === undefined) {
-            return undefined;
-        }
-        return JSON.parse(JSON.stringify(data));
-    }
-    /**
-     * Strips the given properties from an object. Useful for comparing data payloads
-     * where the given props may not be present in the data returned from an adapter.
-     *
-     * Does not mutate the passed in object.
-     *
-     * @param {object} obj The object from which to strip properties
-     * @param {string[]} props The properties to be removed
-     * @returns {object} The updated object with the given props stripped out
-     */
-    function stripProperties(obj, props) {
-        // don't mutate the original object
-        const cloned = clone(obj);
-        stripPropertiesMutating(cloned, props);
-        return cloned;
-    }
-    // private version of strip properties that mutates
-    function stripPropertiesMutating(obj, props) {
-        props.forEach((prop) => {
-            delete obj[prop];
-        });
-        Object.keys(obj).forEach((key) => {
-            const value = obj[key];
-            if (typeof value === 'object' && value !== null) {
-                stripPropertiesMutating(value, props);
-            }
-        });
-    }
-    function doesThrow(predicate) {
-        try {
-            predicate();
-        }
-        catch (e) {
-            return true;
-        }
-        return false;
-    }
-    function flushPromises() {
-        return new Promise((resolve) => setTimeout(resolve, 0));
-    }
-    // Copied from engine to avoid build time dependency
-    // BEGIN OF COPY BLOCK
-    var SnapshotState;
-    (function (SnapshotState) {
-        SnapshotState["Fulfilled"] = "Fulfilled";
-        SnapshotState["Unfulfilled"] = "Unfulfilled";
-        SnapshotState["Error"] = "Error";
-        SnapshotState["Pending"] = "Pending";
-        SnapshotState["Stale"] = "Stale";
-    })(SnapshotState || (SnapshotState = {}));
-    function isErrorSnapshot(snapshot) {
-        return snapshot.state === SnapshotState.Error;
-    }
-    function isFulfilledSnapshot(snapshot) {
-        return snapshot.state === SnapshotState.Fulfilled;
-    }
-    function isStaleSnapshot(snapshot) {
-        return snapshot.state === SnapshotState.Stale;
-    }
-    // END OF COPY BLOCK
-    const customMatchers = {
-        toEqualFulfilledSnapshotWithData: (snapshot, expected, privateProperties) => {
-            if (isFulfilledSnapshot(snapshot)) {
-                const expectedWithoutPrivateProperties = stripProperties(expected, privateProperties || []);
-                expect(snapshot.data).toEqual(expectedWithoutPrivateProperties);
-                expect(isImmutable(snapshot.data)).toBe(true);
-                return { pass: true, message: () => 'Snapshot is a FulfilledSnapshot' };
-            }
-            return {
-                pass: false,
-                message: () => 'Actual Snapshot is not a FulfilledSnapshot.',
-            };
-        },
-        toEqualStaleSnapshotWithData: (snapshot, expected, privateProperties) => {
-            if (isStaleSnapshot(snapshot)) {
-                const expectedWithoutPrivateProperties = stripProperties(expected, privateProperties || []);
-                expect(snapshot.data).toEqual(expectedWithoutPrivateProperties);
-                expect(isImmutable(snapshot.data)).toBe(true);
-                return { pass: true, message: () => 'Snapshot is a StaleSnapshot' };
-            }
-            return {
-                pass: false,
-                message: () => 'Actual Snapshot is not a StaleSnapshot.',
-            };
-        },
-        toEqualErrorSnapshot: (actual, expectedStatus) => {
-            if (isErrorSnapshot(actual)) {
-                expect(isImmutable(actual.error)).toBe(true);
-                expect(actual.data).toBeUndefined();
-                if (expectedStatus !== undefined) {
-                    expect(actual.error.status).toBe(expectedStatus);
-                }
-                return { pass: true, message: () => 'Snapshot is an ErrorSnapshot' };
-            }
-            return {
-                pass: false,
-                message: () => 'Actual Snapshot is not a ErrorSnapshot.',
-            };
-        },
-        toEqualOfflineErrorSnapshot: (actual) => {
-            if (isErrorSnapshot(actual)) {
-                expect(isImmutable(actual.error)).toBe(true);
-                expect(actual.data).toBeUndefined();
-                expect(actual.error).toBeInstanceOf(Error);
-                expect(actual.error.errorType).toBe('networkAdapterError');
-                return {
-                    pass: true,
-                    message: () => 'Snapshot is an ErrorSnapshot',
-                };
-            }
-            return {
-                pass: false,
-                message: () => 'Actual Snapshot is not a ErrorSnapshot.',
-            };
-        },
-        toHaveBeenHitTimes: (mockNetworkAdapter, expected) => {
-            const callCount = getMockNetworkAdapterCallCount(mockNetworkAdapter);
-            if (callCount !== expected) {
-                return {
-                    pass: false,
-                    message: () => `Number of network calls made are different. Actual ${callCount}, Expected ${expected}.`,
-                };
-            }
-            return { pass: true, message: () => `Network calls were made ${expected} times.` };
-        },
-        toHaveBeenHitOnce: (mockNetworkAdapter) => {
-            const callCount = getMockNetworkAdapterCallCount(mockNetworkAdapter);
-            if (callCount !== 1) {
-                return {
-                    pass: false,
-                    message: () => `Number of network calls was not 1. Actual ${callCount}.`,
-                };
-            }
-            return { pass: true, message: () => 'Number of network calls was 1' };
-        },
-        toEqualFetchResponse: (actual, expected) => {
-            expect(actual).toEqual({ ...expected, errorType: 'fetchResponse' });
-            expect(isImmutable(actual)).toBe(true);
-            return { pass: true, message: () => 'Actual response equals expected response' };
-        },
-    };
-
-    const networkConnectivityStateMap = new WeakMap();
-    exports.ConnectivityState = void 0;
-    (function (ConnectivityState) {
-        ConnectivityState[ConnectivityState["Online"] = 0] = "Online";
-        ConnectivityState[ConnectivityState["Offline"] = 1] = "Offline";
-    })(exports.ConnectivityState || (exports.ConnectivityState = {}));
-    const callCountMap = new WeakMap();
-    const mockPayloadsMap = new WeakMap();
-    function buildOfflineError() {
-        return new Error('Failed to fetch, request timeout');
-    }
-    function buildMockSetupError() {
-        return new Error('A mock network response was not setup for this request');
-    }
-    /**
-     * This function sorts two payloads based on number of parameters. It sorts in
-     * ascending order, meaning a MockPayload with fewer parameters in the networkArgs
-     * will come before a MockPayload with more parameters in the networkArgs.
-     *
-     * Sorting really only matters when a two networkArg objects have all the same
-     * fields except for uri/query/headers, so this sorting algorithm is simplistic.
-     * If two networkArg objects have different baseUri or basePath properties, for
-     * example, then the sinon matcher won't have a collision so sorting doesn't
-     * matter in that situation.
-     *
-     * @param {MockPayload} a
-     * @param {MockPayload} b
-     * @returns {number}
-     */
-    function sortPayloads(a, b) {
-        const { networkArgs: { urlParams: bUrlParams, queryParams: bQueryParams, headers: bHeaders }, } = b;
-        const { networkArgs: { urlParams: aUrlParams, queryParams: aQueryParams, headers: aHeaders }, } = a;
-        const aParams = Object.keys(aUrlParams !== null && aUrlParams !== void 0 ? aUrlParams : {}).length +
-            Object.keys(aQueryParams !== null && aQueryParams !== void 0 ? aQueryParams : {}).length +
-            Object.keys(aHeaders !== null && aHeaders !== void 0 ? aHeaders : {}).length;
-        const bParams = Object.keys(bUrlParams !== null && bUrlParams !== void 0 ? bUrlParams : {}).length +
-            Object.keys(bQueryParams !== null && bQueryParams !== void 0 ? bQueryParams : {}).length +
-            Object.keys(bHeaders !== null && bHeaders !== void 0 ? bHeaders : {}).length;
-        return aParams - bParams;
-    }
-    function isOkResponse(status) {
-        return status >= 200 && status <= 299;
-    }
-    /**
-     * Flushes any pending network requests.  Useful for tests that need to ensure all
-     * un-awaited background refreshes are complete
-     *
-     * @param _mockNetworkAdapter {NetworkAdapter} The network adapter instance to flush
-     */
-    async function flushPendingNetworkRequests(_mockNetworkAdapter) {
-        // since the network mock is actually synchronous (just returns things wrapped
-        // in Promise.resolve/reject) the only thing necessary to flush any pending
-        // network activity is to flush the pending microtask queue
-        await flushPromises();
-    }
-    function buildMockNetworkAdapter(mockPayloads) {
-        // any endpoints not setup with a fake will return a rejected promise
-        const networkAdapter = sinon.stub().rejects(buildMockSetupError());
-        callCountMap.set(networkAdapter, 0);
-        mockPayloadsMap.set(networkAdapter, mockPayloads);
-        setMockNetworkPayloads(networkAdapter, mockPayloads);
-        return networkAdapter;
-    }
-    function setNetworkConnectivity(mockNetworkAdapter, connectivityState) {
-        const stub = mockNetworkAdapter;
-        networkConnectivityStateMap.set(stub, connectivityState);
-    }
-    function onNetworkStubCalled(stub, response) {
-        var _a;
-        const { body, status, statusText, ok, headers } = response;
-        const currentCallCount = callCountMap.get(stub);
-        callCountMap.set(stub, currentCallCount ? currentCallCount + 1 : 1);
-        const connectivityState = (_a = networkConnectivityStateMap.get(stub)) !== null && _a !== void 0 ? _a : exports.ConnectivityState.Online;
-        if (connectivityState === exports.ConnectivityState.Offline) {
-            return Promise.reject(buildOfflineError());
-        }
-        return Promise.resolve({
-            status,
-            statusText,
-            ok,
-            body: clone(body),
-            headers: clone(headers),
-        });
-    }
-    function setMockNetworkPayloads(mockNetworkAdapter, mockPayloads) {
-        const stub = mockNetworkAdapter;
-        // sort mock payloads so least-specific network args are registered first
-        mockPayloads.sort(sortPayloads).forEach((mockPayload) => {
-            const { networkArgs, response } = mockPayload;
-            const args = sinon.match(networkArgs);
-            stub.withArgs(args).callsFake(() => {
-                return onNetworkStubCalled(stub, response);
-            });
-        });
-    }
-    /**
-     * Overrides the mock network adapter responses with the given "responses".  Each request to
-     * the network adapter will "pop" a response from the response array.  If more requests
-     * to the network adapter are made than responses in the given array then an error
-     * will be returned.
-     *
-     * This differs from setMockNetworkPayloads because it does not look at the incoming
-     * network request args to determine what the response should be, it just returns
-     * the response based on the request order.
-     *
-     * NOTE: this overrides any previously setup MockPayloads for the given network adapter
-     * until resetMockNetworkAdapter is called.
-     */
-    function overrideMockNetworkResponses(mockNetworkAdapter, responses) {
-        const stub = mockNetworkAdapter;
-        let index = 0;
-        stub.withArgs(sinon.match.any).callsFake(() => {
-            const response = responses[index++];
-            if (response === undefined) {
-                // if they have more requests than expected
-                return Promise.reject(buildMockSetupError());
-            }
-            return onNetworkStubCalled(stub, response);
-        });
-    }
-    function resetMockNetworkAdapter(mockNetworkAdapter, newPayloads) {
-        const stub = mockNetworkAdapter;
-        // reset stub in case a test modified payload responses
-        stub.reset();
-        // reset call count
-        callCountMap.set(stub, 0);
-        // set mock payloads up - Allow for the test to provide a different set of payloads
-        // Default behavior is to reset to the original payloads.
-        const payloads = newPayloads ? newPayloads : mockPayloadsMap.get(stub);
-        if (payloads) {
-            setMockNetworkPayloads(stub, payloads);
-        }
-    }
-    function getMockNetworkAdapterCallCount(mockNetworkAdapter) {
-        const stub = mockNetworkAdapter;
-        return callCountMap.get(stub);
-    }
-    function buildFetchResponse(body, status = 200, statusText = 'Ok', headers = {}) {
-        return {
-            headers,
-            body,
-            status,
-            statusText,
-            ok: isOkResponse(status),
-        };
-    }
-    function buildSuccessMockPayload(networkArgs, body, headers = {}) {
-        const mockPayload = {
-            networkArgs,
-            response: buildFetchResponse(body, 200, 'Ok', headers),
-        };
-        return mockPayload;
-    }
-    function buildErrorMockPayload(networkArgs, body, errorStatusCode, errorStatusText, headers = {}) {
-        const mockPayload = {
-            networkArgs,
-            response: buildFetchResponse(body, errorStatusCode, errorStatusText, headers),
-        };
-        return mockPayload;
-    }
-
-    const mockFulfilledSnapshot = { state: 'Fulfilled' };
-    const mockFulfilledSnapshotPromise = {
-        then() {
-            return mockFulfilledSnapshot;
-        },
-    };
-    const mockLuvio = {
-        storeLookup() {
-            return mockFulfilledSnapshot;
-        },
-        snapshotAvailable() {
-            return true;
-        },
-        dispatchResourceRequest() {
-            return mockFulfilledSnapshotPromise;
-        },
-        applyCachePolicy() {
-            return mockFulfilledSnapshot;
-        },
-    };
-    function getMockLuvioWithFulfilledSnapshot() {
-        return mockLuvio;
-    }
-    function getMockFulfilledSnapshot() {
-        return mockFulfilledSnapshot;
-    }
-
-    function setupCustomLuvioMatchers() {
-        expect.extend(customMatchers);
-    }
-
-    class MemoryDurableStorePersistence {
-        constructor() {
-            this.store = {};
-        }
-        async get(key) {
-            return this.store[key];
-        }
-        async set(key, value) {
-            // simulate a more realistic durable store by making the write wait a
-            // tick before actually setting the value
-            await flushPromises();
-            this.store[key] = value;
-        }
-        async delete(key) {
-            delete this.store[key];
-        }
-        async flushPendingWork() {
-            // since this implementation does actual "IO" synchronously the only
-            // thing necessary to await any pending IO is to flush the current
-            // microtask queue
-            await flushPromises();
-        }
-    }
-
-    function waitForPromiseSet(set) {
-        // NOTE: we are building an array from the Set at this point in time.  If
-        // more Promises are added to the Set while this is awaiting it won't
-        // await the newly-added Promise.  That's what we want.
-        return Promise.all(Array.from(set)).then();
-    }
-    class MockDurableStore {
-        constructor(persistence) {
-            // for read/write synchronization
-            this.writePromises = new Set();
-            this.listeners = new Set();
-            this.persistence = persistence || new MemoryDurableStorePersistence();
-        }
-        async getEntries(entryIds, segment) {
-            // await any current write operations
-            if (this.writePromises.size > 0) {
-                await waitForPromiseSet(this.writePromises);
-            }
-            const entries = await this.persistence.get(segment);
-            if (entries === undefined) {
-                return undefined;
-            }
-            const returnSource = Object.create(null);
-            for (const entryId of entryIds) {
-                const entry = entries[entryId];
-                if (entry !== undefined) {
-                    returnSource[entryId] = clone(entry);
-                }
-            }
-            return returnSource;
-        }
-        async getAllEntries(segment) {
-            // await any current write operations
-            if (this.writePromises.size > 0) {
-                await waitForPromiseSet(this.writePromises);
-            }
-            const entries = await this.persistence.get(segment);
-            return entries;
-        }
-        setEntries(entries, segment) {
-            return this.batchOperations([{ entries, segment, type: 'setEntries' }]);
-        }
-        evictEntries(ids, segment) {
-            return this.batchOperations([{ ids, segment, type: 'evictEntries' }]);
-        }
-        registerOnChangedListener(listener) {
-            this.listeners.add(listener);
-            return () => {
-                this.listeners.delete(listener);
-                return Promise.resolve();
-            };
-        }
-        async batchOperations(operations) {
-            // await any current write operations
-            if (this.writePromises.size > 0) {
-                await waitForPromiseSet(this.writePromises);
-            }
-            const changes = [];
-            const writePromise = (async () => {
-                for (const operation of operations) {
-                    changes.push(await this.performOperation(operation));
-                }
-            })();
-            this.writePromises.add(writePromise);
-            try {
-                await writePromise;
-            }
-            finally {
-                this.writePromises.delete(writePromise);
-            }
-            const promises = [];
-            this.listeners.forEach((listener) => {
-                promises.push(listener(changes));
-            });
-            return Promise.all(promises).then(() => undefined);
-        }
-        async performOperation(operation) {
-            const segment = operation.segment;
-            const rawEntries = await this.persistence.get(segment);
-            const entries = rawEntries === undefined ? {} : rawEntries;
-            let ids = [];
-            switch (operation.type) {
-                case 'setEntries':
-                    ids = Object.keys(operation.entries);
-                    ids.forEach((id) => {
-                        entries[id] = clone(operation.entries[id]);
-                    });
-                    break;
-                case 'evictEntries':
-                    ids = operation.ids;
-                    ids.forEach((id) => {
-                        delete entries[id];
-                    });
-            }
-            await this.persistence.set(operation.segment, entries);
-            return { ids, segment, type: operation.type };
-        }
-        async flushPendingOperations() {
-            // flush any pending read operations
-            await this.persistence.flushPendingWork();
-            // wait for any pending writes to finish
-            while (this.writePromises.size > 0) {
-                await waitForPromiseSet(this.writePromises);
-            }
-        }
-    }
-
-    // Use this util if you want to configure multiple network mocks in your test code.
-    // If you're only mocking one, we suggest you use buildLuvioWithNetwork instead.
-    function buildLuvioInstance(mockNetworkAdapter) {
-        const store = new engine.InMemoryStore();
-        const env = new engine.Environment(store, mockNetworkAdapter);
-        return new engine.Luvio(env);
-    }
-    async function testAdapterCompletesRoundtrip(params) {
-        const adapterSetup = setupAdapter(params);
-        const result = await callAdapter(adapterSetup, params);
-        expect(result.data).toBeDefined();
-        expect(result).toEqualFulfilledSnapshotWithData(params.type === 'network'
-            ? params.expectedData || params.network.response
-            : params.expectedData, params.privateProperties);
-        return result;
-    }
-    function setupAdapter(params) {
-        const luvio = params.type === 'network' ? buildLuvioWithNetwork(params.network).luvio : params.luvio;
-        return params.adapterFactory(luvio);
-    }
-    // Returns a tuple of the Luvio instance and network adapter so the test author may expect a number expected calls to the network.
-    function buildLuvioWithNetwork(networkConfig) {
-        // TODO: handle alternative expected network calls, errors and etc
-        const expectedNetwork = [
-            buildSuccessMockPayload(networkConfig.request, networkConfig.response),
-        ];
-        const mockNetworkAdapter = buildMockNetworkAdapter(expectedNetwork);
-        return { luvio: buildLuvioInstance(mockNetworkAdapter), networkAdapter: mockNetworkAdapter };
-    }
-    async function callAdapter(adapter, params) {
-        const snapshotOrPromise = adapter(params.adapterConfig);
-        if (snapshotOrPromise === null) {
-            throw new Error('Result of calling the adapter was null. Is the adapter config valid?');
-        }
-        // Cache Miss - Check that the network call was right.
-        if (params.type === 'injectedLuvioNetwork' || params.type === 'network') {
-            expect(snapshotOrPromise).toBeInstanceOf(Promise);
-            return snapshotOrPromise;
-        }
-        else {
-            // Cache hit
-            expect(snapshotOrPromise).not.toBeInstanceOf(Promise); // Expect cache hit to be synchronous
-            return Promise.resolve(snapshotOrPromise);
-        }
-    }
-
-    exports.MemoryDurableStorePersistence = MemoryDurableStorePersistence;
-    exports.MockDurableStore = MockDurableStore;
-    exports.buildErrorMockPayload = buildErrorMockPayload;
-    exports.buildFetchResponse = buildFetchResponse;
-    exports.buildLuvioInstance = buildLuvioInstance;
-    exports.buildLuvioWithNetwork = buildLuvioWithNetwork;
-    exports.buildMockNetworkAdapter = buildMockNetworkAdapter;
-    exports.buildSuccessMockPayload = buildSuccessMockPayload;
-    exports.customMatchers = customMatchers;
-    exports.flushPendingNetworkRequests = flushPendingNetworkRequests;
-    exports.getMockFulfilledSnapshot = getMockFulfilledSnapshot;
-    exports.getMockLuvioWithFulfilledSnapshot = getMockLuvioWithFulfilledSnapshot;
-    exports.getMockNetworkAdapterCallCount = getMockNetworkAdapterCallCount;
-    exports.isImmutable = isImmutable;
-    exports.overrideMockNetworkResponses = overrideMockNetworkResponses;
-    exports.resetMockNetworkAdapter = resetMockNetworkAdapter;
-    exports.setMockNetworkPayloads = setMockNetworkPayloads;
-    exports.setNetworkConnectivity = setNetworkConnectivity;
-    exports.setupCustomLuvioMatchers = setupCustomLuvioMatchers;
-    exports.stripProperties = stripProperties;
-    exports.testAdapterCompletesRoundtrip = testAdapterCompletesRoundtrip;
-    exports.verifyImmutable = verifyImmutable;
-
-}));

package/dist/umd/es2018/types/MockDurableStore.d.ts

@@ -1,16 +0,0 @@
-import type { DurableStore, DurableStoreEntries, OnDurableStoreChangedListener, DurableStoreOperation } from '@luvio/environments';
-import type { DurableStorePersistence } from './durableStorePersistence';
-export declare class MockDurableStore implements DurableStore {
-    private writePromises;
-    listeners: Set<OnDurableStoreChangedListener>;
-    persistence: DurableStorePersistence;
-    constructor(persistence?: DurableStorePersistence);
-    getEntries<T>(entryIds: string[], segment: string): Promise<DurableStoreEntries<T> | undefined>;
-    getAllEntries<T>(segment: string): Promise<DurableStoreEntries<T> | undefined>;
-    setEntries<T>(entries: DurableStoreEntries<T>, segment: string): Promise<void>;
-    evictEntries(ids: string[], segment: string): Promise<void>;
-    registerOnChangedListener(listener: OnDurableStoreChangedListener): () => Promise<void>;
-    batchOperations<T>(operations: DurableStoreOperation<T>[]): Promise<void>;
-    private performOperation;
-    flushPendingOperations(): Promise<void>;
-}