@luvio/lwc-luvio 0.138.1 → 0.138.2

package/dist/umd/es5/lwcluvio.js

@@ -4,360 +4,360 @@
     (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.lwcLuvio = {}, global.LWC));
 })(this, (function (exports, lwc) { 'use strict';
 
-    // instrumentation keys to be imported by ldsInstrumentation
-    var REFRESH_ADAPTER_EVENT = 'refresh-adapter-event';
-    var ADAPTER_UNFULFILLED_ERROR = 'adapter-unfulfilled-error';
-    var USERLAND_PROVISION_ERROR_MESSAGE = "LWC component's @wire target property or method threw an error during value provisioning. Original error:";
-    var ADAPTER_SNAPSHOT_REJECTED_MESSAGE = 'Luvio wire adapter Promise<Snapshot> rejected. Original error:';
+    // instrumentation keys to be imported by ldsInstrumentation
+    var REFRESH_ADAPTER_EVENT = 'refresh-adapter-event';
+    var ADAPTER_UNFULFILLED_ERROR = 'adapter-unfulfilled-error';
+    var USERLAND_PROVISION_ERROR_MESSAGE = "LWC component's @wire target property or method threw an error during value provisioning. Original error:";
+    var ADAPTER_SNAPSHOT_REJECTED_MESSAGE = 'Luvio wire adapter Promise<Snapshot> rejected. Original error:';
     var USERLAND_GRAPHQL_PARSER_ERROR_MESSAGE = 'Use `gql` parser to parse your "query" string';
 
-    // map of emitted object -> [ adapter name, snapshot ]; snapshot is only undefined for the
-    // initially-emitted { data: undefined, error: undefined } value
+    // map of emitted object -> [ adapter name, snapshot ]; snapshot is only undefined for the
+    // initially-emitted { data: undefined, error: undefined } value
     var dataToTupleWeakMap = new WeakMap();
 
-    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;
-    }
-    function isUnfulfilledSnapshot(snapshot) {
-        return snapshot.state === SnapshotState.Unfulfilled;
-    }
-    /**
-     * Transform a Snapshot into a payload suitable for passing to a DataCallback.
-     *
-     * @param snapshot Snapshot
-     */
-    function snapshotToPayload$1(snapshot) {
-        if (snapshot === undefined) {
-            return {
-                data: undefined,
-                error: undefined,
-            };
-        }
-        if (isErrorSnapshot(snapshot)) {
-            return {
-                data: undefined,
-                error: snapshot.error,
-            };
-        }
-        // fulfilled or stale
-        return {
-            data: snapshot.data,
-            error: undefined,
-        };
+    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;
+    }
+    function isUnfulfilledSnapshot(snapshot) {
+        return snapshot.state === SnapshotState.Unfulfilled;
+    }
+    /**
+     * Transform a Snapshot into a payload suitable for passing to a DataCallback.
+     *
+     * @param snapshot Snapshot
+     */
+    function snapshotToPayload$1(snapshot) {
+        if (snapshot === undefined) {
+            return {
+                data: undefined,
+                error: undefined,
+            };
+        }
+        if (isErrorSnapshot(snapshot)) {
+            return {
+                data: undefined,
+                error: snapshot.error,
+            };
+        }
+        // fulfilled or stale
+        return {
+            data: snapshot.data,
+            error: undefined,
+        };
     }
 
-    function bindWireRefresh(luvio) {
-        return function refresh(data) {
-            return refreshData(data, dataToTupleWeakMap, luvio);
-        };
-    }
-    function refreshData(data, dataToTuple, luvio) {
-        var tuple = dataToTuple.get(lwc.unwrap(data));
-        if (tuple === undefined) {
-            if (process.env.NODE_ENV !== 'production') {
-                throw new Error('Refresh failed because resolved configuration is not available.');
-            }
-            return;
-        }
-        var adapterName = tuple[0], snapshot = tuple[1];
-        luvio.instrument(function () {
-            var _a;
-            return _a = {},
-                _a[REFRESH_ADAPTER_EVENT] = true,
-                _a.adapterName = adapterName,
-                _a;
-        });
-        // snapshot is undefined when a caller refreshes the initial
-        // { data: undefined, error: undefined } object that we emitted
-        if (snapshot === undefined) {
-            return Promise.resolve(undefined);
-        }
-        return luvio.refreshSnapshot(snapshot).then(function (refreshed) {
-            if (isErrorSnapshot(refreshed)) {
-                throw refreshed.error;
-            }
-            if (process.env.NODE_ENV !== 'production') {
-                if (isUnfulfilledSnapshot(refreshed)) {
-                    throw new Error('Refresh resulted in unfulfilled snapshot');
-                }
-            }
-            return undefined;
-        });
+    function bindWireRefresh(luvio) {
+        return function refresh(data) {
+            return refreshData(data, dataToTupleWeakMap, luvio);
+        };
+    }
+    function refreshData(data, dataToTuple, luvio) {
+        var tuple = dataToTuple.get(lwc.unwrap(data));
+        if (tuple === undefined) {
+            if (process.env.NODE_ENV !== 'production') {
+                throw new Error('Refresh failed because resolved configuration is not available.');
+            }
+            return;
+        }
+        var adapterName = tuple[0], snapshot = tuple[1];
+        luvio.instrument(function () {
+            var _a;
+            return _a = {},
+                _a[REFRESH_ADAPTER_EVENT] = true,
+                _a.adapterName = adapterName,
+                _a;
+        });
+        // snapshot is undefined when a caller refreshes the initial
+        // { data: undefined, error: undefined } object that we emitted
+        if (snapshot === undefined) {
+            return Promise.resolve(undefined);
+        }
+        return luvio.refreshSnapshot(snapshot).then(function (refreshed) {
+            if (isErrorSnapshot(refreshed)) {
+                throw refreshed.error;
+            }
+            if (process.env.NODE_ENV !== 'production') {
+                if (isUnfulfilledSnapshot(refreshed)) {
+                    throw new Error('Refresh resulted in unfulfilled snapshot');
+                }
+            }
+            return undefined;
+        });
     }
 
-    var keys = Object.keys;
-    var isArray = Array.isArray;
+    var keys = Object.keys;
+    var isArray = Array.isArray;
     var stringify = JSON.stringify;
 
-    function isPromise(value) {
-        // check for Thenable due to test frameworks using custom Promise impls
-        return value.then !== undefined;
+    function isPromise(value) {
+        // check for Thenable due to test frameworks using custom Promise impls
+        return value.then !== undefined;
     }
 
-    /**
-     * (Re)throws an error after adding a prefix to the message.
-     *
-     * @param error Error
-     * @param messagePrefix prefix to add to error's message
-     */
-    function throwAnnotatedError(error, messagePrefix) {
-        if (error instanceof Error) {
-            error.message = "".concat(messagePrefix, "\n[").concat(error.message, "]");
-            throw error;
-        }
-        throw new Error("".concat(messagePrefix, "\n[").concat(stringify(error), "]"));
+    /**
+     * (Re)throws an error after adding a prefix to the message.
+     *
+     * @param error Error
+     * @param messagePrefix prefix to add to error's message
+     */
+    function throwAnnotatedError(error, messagePrefix) {
+        if (error instanceof Error) {
+            error.message = "".concat(messagePrefix, "\n[").concat(error.message, "]");
+            throw error;
+        }
+        throw new Error("".concat(messagePrefix, "\n[").concat(stringify(error), "]"));
     }
 
-    var Sanitizer = /** @class */ (function () {
-        function Sanitizer(obj) {
-            this.obj = obj;
-            this.copy = {};
-            this.currentPath = {
-                key: '',
-                value: obj,
-                parent: null,
-                data: this.copy,
-            };
-        }
-        Sanitizer.prototype.sanitize = function () {
-            var sanitizer = this;
-            stringify(this.obj, function (key, value) {
-                if (key === '') {
-                    return value;
-                }
-                var parent = this;
-                if (parent !== sanitizer.currentPath.value) {
-                    sanitizer.exit(parent);
-                }
-                if (typeof value === 'object' && value !== null) {
-                    sanitizer.enter(key, value);
-                    return value;
-                }
-                sanitizer.currentPath.data[key] = value;
-                return value;
-            });
-            return this.copy;
-        };
-        Sanitizer.prototype.enter = function (key, value) {
-            var parentPath = this.currentPath;
-            var data = (parentPath.data[key] = isArray(value) ? [] : {});
-            this.currentPath = {
-                key: key,
-                value: value,
-                parent: parentPath,
-                data: data,
-            };
-        };
-        Sanitizer.prototype.exit = function (parent) {
-            while (this.currentPath.value !== parent) {
-                this.currentPath = this.currentPath.parent || this.currentPath;
-            }
-        };
-        return Sanitizer;
-    }());
-    /**
-     * Returns a sanitized version of an object by recursively unwrapping the Proxies.
-     *
-     * In order to keep luvio performance optimal on IE11, we need to make sure that luvio code gets
-     * transformed by the es5-proxy-compat. At the same time we need to ensure that no ProxyCompat leaks
-     * into the luvio engine code nor into the adapters. All the data coming from LWC-land need to be
-     * sanitized first.
-     */
-    function sanitize(obj) {
-        return new Sanitizer(obj).sanitize();
+    var Sanitizer = /** @class */ (function () {
+        function Sanitizer(obj) {
+            this.obj = obj;
+            this.copy = {};
+            this.currentPath = {
+                key: '',
+                value: obj,
+                parent: null,
+                data: this.copy,
+            };
+        }
+        Sanitizer.prototype.sanitize = function () {
+            var sanitizer = this;
+            stringify(this.obj, function (key, value) {
+                if (key === '') {
+                    return value;
+                }
+                var parent = this;
+                if (parent !== sanitizer.currentPath.value) {
+                    sanitizer.exit(parent);
+                }
+                if (typeof value === 'object' && value !== null) {
+                    sanitizer.enter(key, value);
+                    return value;
+                }
+                sanitizer.currentPath.data[key] = value;
+                return value;
+            });
+            return this.copy;
+        };
+        Sanitizer.prototype.enter = function (key, value) {
+            var parentPath = this.currentPath;
+            var data = (parentPath.data[key] = isArray(value) ? [] : {});
+            this.currentPath = {
+                key: key,
+                value: value,
+                parent: parentPath,
+                data: data,
+            };
+        };
+        Sanitizer.prototype.exit = function (parent) {
+            while (this.currentPath.value !== parent) {
+                this.currentPath = this.currentPath.parent || this.currentPath;
+            }
+        };
+        return Sanitizer;
+    }());
+    /**
+     * Returns a sanitized version of an object by recursively unwrapping the Proxies.
+     *
+     * In order to keep luvio performance optimal on IE11, we need to make sure that luvio code gets
+     * transformed by the es5-proxy-compat. At the same time we need to ensure that no ProxyCompat leaks
+     * into the luvio engine code nor into the adapters. All the data coming from LWC-land need to be
+     * sanitized first.
+     */
+    function sanitize(obj) {
+        return new Sanitizer(obj).sanitize();
     }
 
-    var LWCLuvioWireAdapter = /** @class */ (function () {
-        /**
-         * Constructs a new wire adapter instance for the given adapter.
-         *
-         * @param callback callback to be invoked with new values
-         */
-        function LWCLuvioWireAdapter(adapter, name, luvio, callback) {
-            // a component can be connected-disconnected-reconnected multiple times during its
-            // life but we only want to keep subscriptions active while it is connected; the
-            // connect/disconnect methods below keep this value updated to reflect the current
-            // state
-            this.connected = false;
-            this.adapter = adapter;
-            this.name = name;
-            this.luvio = luvio;
-            this.callback = callback;
-            // initialize the wired property with a properly shaped object so cmps can use <template if:true={wiredProperty.data}>
-            this.emit();
-        }
-        // WireAdapter interface methods
-        /**
-         * Called when the component associated with the wire adapter is connected.
-         */
-        LWCLuvioWireAdapter.prototype.connect = function () {
-            this.connected = true;
-            this.callAdapter();
-        };
-        /**
-         * Called when the component associated with the wire adapter is disconnected.
-         */
-        LWCLuvioWireAdapter.prototype.disconnect = function () {
-            this.unsubscribe();
-            this.connected = false;
-        };
-        /**
-         * Called when new or updated config is supplied to the wire adapter.
-         *
-         * @param config new config parameters for the wire adapter
-         * @param _context not used
-         */
-        LWCLuvioWireAdapter.prototype.update = function (config, _context) {
-            this.unsubscribe();
-            this.config = sanitize(config);
-            this.callAdapter();
-        };
-        // private and protected utility methods
-        /**
-         * Calls the adapter if config has been set and the component is connected.
-         */
-        LWCLuvioWireAdapter.prototype.callAdapter = function () {
-            if (!this.connected || this.config === undefined) {
-                return;
-            }
-            var snapshotOrPromise = this.adapter(this.config);
-            this.processAdapterResponse(snapshotOrPromise);
-        };
-        LWCLuvioWireAdapter.prototype.processAdapterResponse = function (snapshotOrPromise) {
-            var _this = this;
-            // insufficient config, wait for new config from component
-            if (snapshotOrPromise === null) {
-                return;
-            }
-            var configForSnapshot = this.config;
-            var emitAndSubscribe = function (snapshot) {
-                // adapters leveraging adapter context could asynchronously
-                // return null (due to invalid config)
-                if (snapshot === null) {
-                    return;
-                }
-                // We should never broadcast an unfulfilled snapshot to a component
-                if (isUnfulfilledSnapshot(snapshot)) {
-                    if (process.env.NODE_ENV !== 'production') {
-                        throw new Error("Unfulfilled snapshot emitted to component from subscription, missingPaths: ".concat(keys(snapshot.missingPaths)));
-                    }
-                    // Instrument as a failed request
-                    _this.luvio.instrument(function () {
-                        var _a;
-                        return _a = {},
-                            _a[ADAPTER_UNFULFILLED_ERROR] = true,
-                            _a.adapterName = _this.adapter.name,
-                            _a.missingPaths = snapshot.missingPaths,
-                            _a.missingLinks = snapshot.missingLinks,
-                            _a;
-                    });
-                    return;
-                }
-                // if config has changed before the snapshot arrives then ignore snapshot
-                if (_this.config !== configForSnapshot) {
-                    return;
-                }
-                // emit unless snapshot is pending
-                if (isFulfilledSnapshot(snapshot) ||
-                    isErrorSnapshot(snapshot) ||
-                    isStaleSnapshot(snapshot)) {
-                    _this.emit(snapshot);
-                }
-                // subscribe to the new snapshot
-                _this.subscribe(snapshot);
-            };
-            // Data resolved sync
-            if (!isPromise(snapshotOrPromise)) {
-                emitAndSubscribe(snapshotOrPromise);
-            }
-            else {
-                // We want to let errors from this promise propagate to the app container,
-                // which is why we do not have a reject handler here.
-                // If an error is thrown here, it means that there was an error somewhere
-                // inside an adapter which means that there was a mistake by the implementor.
-                // Errors that come from the network should never hit this block because
-                // they are treated like regular snapshots, not true error paths.
-                snapshotOrPromise.then(emitAndSubscribe, function (error) {
-                    return throwAnnotatedError(error, ADAPTER_SNAPSHOT_REJECTED_MESSAGE);
-                });
-            }
-        };
-        /**
-         * Emits new values to the callback.
-         *
-         * @param snapshot Snapshot to be emitted, if omitted then undefineds will be emitted
-         */
-        LWCLuvioWireAdapter.prototype.emit = function (snapshot) {
-            var payload = snapshotToPayload$1(snapshot);
-            dataToTupleWeakMap.set(payload, [this.name, snapshot]);
-            try {
-                this.callback(payload);
-            }
-            catch (error) {
-                if (error instanceof Error) {
-                    throwAnnotatedError(error, USERLAND_PROVISION_ERROR_MESSAGE);
-                }
-            }
-        };
-        /**
-         * Subscribes this wire adapter to future changes to the specified snapshot. Any changes
-         * to the snapshot will be automatically emitted to the component.
-         *
-         * @param snapshot Snapshot
-         * @param subscriptionCallback callback
-         */
-        LWCLuvioWireAdapter.prototype.subscribe = function (snapshot) {
-            // always clean up any old subscription that we might have
-            this.unsubscribe();
-            // but only subscribe if component is currently connected
-            if (this.connected) {
-                this.unsubscriber = this.luvio.storeSubscribe(snapshot, this.emit.bind(this));
-            }
-        };
-        /**
-         * Deletes this wire adapter's snapshot subscription (if any).
-         */
-        LWCLuvioWireAdapter.prototype.unsubscribe = function () {
-            // clean up subscription
-            if (this.unsubscriber !== undefined) {
-                this.unsubscriber();
-                this.unsubscriber = undefined;
-            }
-        };
-        return LWCLuvioWireAdapter;
-    }());
-    /**
-     * Wraps a luvio Adapter in a WireAdapterConstructor that conforms to https://rfcs.lwc.dev/rfcs/lwc/0000-wire-reform#wire-adapter-protocol.
-     *
-     * @param adapter Adapter
-     * @param name name to assign to the generated constructor
-     * @param luvio Luvio
-     */
-    function createWireAdapterConstructor(adapter, name, luvio) {
-        var constructor = function (callback) {
-            var delegate = new LWCLuvioWireAdapter(adapter, name, luvio, callback);
-            this.connect = function () { return delegate.connect(); };
-            this.disconnect = function () { return delegate.disconnect(); };
-            this.update = function (config, context) {
-                return delegate.update(config, context);
-            };
-        };
-        Object.defineProperty(constructor, 'name', { value: name });
-        return constructor;
+    var LWCLuvioWireAdapter = /** @class */ (function () {
+        /**
+         * Constructs a new wire adapter instance for the given adapter.
+         *
+         * @param callback callback to be invoked with new values
+         */
+        function LWCLuvioWireAdapter(adapter, name, luvio, callback) {
+            // a component can be connected-disconnected-reconnected multiple times during its
+            // life but we only want to keep subscriptions active while it is connected; the
+            // connect/disconnect methods below keep this value updated to reflect the current
+            // state
+            this.connected = false;
+            this.adapter = adapter;
+            this.name = name;
+            this.luvio = luvio;
+            this.callback = callback;
+            // initialize the wired property with a properly shaped object so cmps can use <template if:true={wiredProperty.data}>
+            this.emit();
+        }
+        // WireAdapter interface methods
+        /**
+         * Called when the component associated with the wire adapter is connected.
+         */
+        LWCLuvioWireAdapter.prototype.connect = function () {
+            this.connected = true;
+            this.callAdapter();
+        };
+        /**
+         * Called when the component associated with the wire adapter is disconnected.
+         */
+        LWCLuvioWireAdapter.prototype.disconnect = function () {
+            this.unsubscribe();
+            this.connected = false;
+        };
+        /**
+         * Called when new or updated config is supplied to the wire adapter.
+         *
+         * @param config new config parameters for the wire adapter
+         * @param _context not used
+         */
+        LWCLuvioWireAdapter.prototype.update = function (config, _context) {
+            this.unsubscribe();
+            this.config = sanitize(config);
+            this.callAdapter();
+        };
+        // private and protected utility methods
+        /**
+         * Calls the adapter if config has been set and the component is connected.
+         */
+        LWCLuvioWireAdapter.prototype.callAdapter = function () {
+            if (!this.connected || this.config === undefined) {
+                return;
+            }
+            var snapshotOrPromise = this.adapter(this.config);
+            this.processAdapterResponse(snapshotOrPromise);
+        };
+        LWCLuvioWireAdapter.prototype.processAdapterResponse = function (snapshotOrPromise) {
+            var _this = this;
+            // insufficient config, wait for new config from component
+            if (snapshotOrPromise === null) {
+                return;
+            }
+            var configForSnapshot = this.config;
+            var emitAndSubscribe = function (snapshot) {
+                // adapters leveraging adapter context could asynchronously
+                // return null (due to invalid config)
+                if (snapshot === null) {
+                    return;
+                }
+                // We should never broadcast an unfulfilled snapshot to a component
+                if (isUnfulfilledSnapshot(snapshot)) {
+                    if (process.env.NODE_ENV !== 'production') {
+                        throw new Error("Unfulfilled snapshot emitted to component from subscription, missingPaths: ".concat(keys(snapshot.missingPaths)));
+                    }
+                    // Instrument as a failed request
+                    _this.luvio.instrument(function () {
+                        var _a;
+                        return _a = {},
+                            _a[ADAPTER_UNFULFILLED_ERROR] = true,
+                            _a.adapterName = _this.adapter.name,
+                            _a.missingPaths = snapshot.missingPaths,
+                            _a.missingLinks = snapshot.missingLinks,
+                            _a;
+                    });
+                    return;
+                }
+                // if config has changed before the snapshot arrives then ignore snapshot
+                if (_this.config !== configForSnapshot) {
+                    return;
+                }
+                // emit unless snapshot is pending
+                if (isFulfilledSnapshot(snapshot) ||
+                    isErrorSnapshot(snapshot) ||
+                    isStaleSnapshot(snapshot)) {
+                    _this.emit(snapshot);
+                }
+                // subscribe to the new snapshot
+                _this.subscribe(snapshot);
+            };
+            // Data resolved sync
+            if (!isPromise(snapshotOrPromise)) {
+                emitAndSubscribe(snapshotOrPromise);
+            }
+            else {
+                // We want to let errors from this promise propagate to the app container,
+                // which is why we do not have a reject handler here.
+                // If an error is thrown here, it means that there was an error somewhere
+                // inside an adapter which means that there was a mistake by the implementor.
+                // Errors that come from the network should never hit this block because
+                // they are treated like regular snapshots, not true error paths.
+                snapshotOrPromise.then(emitAndSubscribe, function (error) {
+                    return throwAnnotatedError(error, ADAPTER_SNAPSHOT_REJECTED_MESSAGE);
+                });
+            }
+        };
+        /**
+         * Emits new values to the callback.
+         *
+         * @param snapshot Snapshot to be emitted, if omitted then undefineds will be emitted
+         */
+        LWCLuvioWireAdapter.prototype.emit = function (snapshot) {
+            var payload = snapshotToPayload$1(snapshot);
+            dataToTupleWeakMap.set(payload, [this.name, snapshot]);
+            try {
+                this.callback(payload);
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    throwAnnotatedError(error, USERLAND_PROVISION_ERROR_MESSAGE);
+                }
+            }
+        };
+        /**
+         * Subscribes this wire adapter to future changes to the specified snapshot. Any changes
+         * to the snapshot will be automatically emitted to the component.
+         *
+         * @param snapshot Snapshot
+         * @param subscriptionCallback callback
+         */
+        LWCLuvioWireAdapter.prototype.subscribe = function (snapshot) {
+            // always clean up any old subscription that we might have
+            this.unsubscribe();
+            // but only subscribe if component is currently connected
+            if (this.connected) {
+                this.unsubscriber = this.luvio.storeSubscribe(snapshot, this.emit.bind(this));
+            }
+        };
+        /**
+         * Deletes this wire adapter's snapshot subscription (if any).
+         */
+        LWCLuvioWireAdapter.prototype.unsubscribe = function () {
+            // clean up subscription
+            if (this.unsubscriber !== undefined) {
+                this.unsubscriber();
+                this.unsubscriber = undefined;
+            }
+        };
+        return LWCLuvioWireAdapter;
+    }());
+    /**
+     * Wraps a luvio Adapter in a WireAdapterConstructor that conforms to https://rfcs.lwc.dev/rfcs/lwc/0000-wire-reform#wire-adapter-protocol.
+     *
+     * @param adapter Adapter
+     * @param name name to assign to the generated constructor
+     * @param luvio Luvio
+     */
+    function createWireAdapterConstructor(adapter, name, luvio) {
+        var constructor = function (callback) {
+            var delegate = new LWCLuvioWireAdapter(adapter, name, luvio, callback);
+            this.connect = function () { return delegate.connect(); };
+            this.disconnect = function () { return delegate.disconnect(); };
+            this.update = function (config, context) {
+                return delegate.update(config, context);
+            };
+        };
+        Object.defineProperty(constructor, 'name', { value: name });
+        return constructor;
     }
 
     /******************************************************************************
@@ -402,211 +402,211 @@
         return __assign.apply(this, arguments);
     };
 
-    var LWCInfinteScrollingLuvioWireAdapter = /** @class */ (function (_super) {
-        __extends(LWCInfinteScrollingLuvioWireAdapter, _super);
-        function LWCInfinteScrollingLuvioWireAdapter() {
-            return _super !== null && _super.apply(this, arguments) || this;
-        }
-        /**
-         * Called when the component associated with the wire adapter is connected.
-         */
-        LWCInfinteScrollingLuvioWireAdapter.prototype.connect = function () {
-            this.connectTimestamp = Date.now();
-            _super.prototype.connect.call(this);
-        };
-        /**
-         * Called when the component associated with the wire adapter is disconnected.
-         */
-        LWCInfinteScrollingLuvioWireAdapter.prototype.disconnect = function () {
-            this.connectTimestamp = undefined;
-            _super.prototype.disconnect.call(this);
-        };
-        /**
-         * Called when new or updated config is supplied to the wire adapter.
-         *
-         * @param config new config parameters for the wire adapter
-         * @param context context for the wire adapter
-         */
-        LWCInfinteScrollingLuvioWireAdapter.prototype.update = function (config, context) {
-            if (this.connectTimestamp) {
-                var mergedContext = Object.assign({
-                    cachePolicy: {
-                        type: 'valid-at',
-                        timestamp: this.connectTimestamp,
-                    },
-                }, context);
-                _super.prototype.unsubscribe.call(this);
-                this.config = sanitize(config);
-                this.callAdapterWithContext(mergedContext);
-            }
-            else {
-                _super.prototype.update.call(this, config, context);
-            }
-        };
-        /**
-         * Calls the adapter if config has been set and the component is connected.
-         */
-        LWCInfinteScrollingLuvioWireAdapter.prototype.callAdapterWithContext = function (context) {
-            if (!this.connected || this.config === undefined) {
-                return;
-            }
-            var snapshotOrPromise = this.adapter(this.config, context);
-            _super.prototype.processAdapterResponse.call(this, snapshotOrPromise);
-        };
-        return LWCInfinteScrollingLuvioWireAdapter;
-    }(LWCLuvioWireAdapter));
-    function createInfiniteScrollingWireAdapterConstructor(adapter, name, luvio) {
-        var constructor = function (callback) {
-            var delegate = new LWCInfinteScrollingLuvioWireAdapter(adapter, name, luvio, callback);
-            this.connect = function () { return delegate.connect(); };
-            this.disconnect = function () { return delegate.disconnect(); };
-            this.update = function (config, context) {
-                return delegate.update(config, context);
-            };
-        };
-        Object.defineProperty(constructor, 'name', { value: name });
-        return constructor;
+    var LWCInfinteScrollingLuvioWireAdapter = /** @class */ (function (_super) {
+        __extends(LWCInfinteScrollingLuvioWireAdapter, _super);
+        function LWCInfinteScrollingLuvioWireAdapter() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        /**
+         * Called when the component associated with the wire adapter is connected.
+         */
+        LWCInfinteScrollingLuvioWireAdapter.prototype.connect = function () {
+            this.connectTimestamp = Date.now();
+            _super.prototype.connect.call(this);
+        };
+        /**
+         * Called when the component associated with the wire adapter is disconnected.
+         */
+        LWCInfinteScrollingLuvioWireAdapter.prototype.disconnect = function () {
+            this.connectTimestamp = undefined;
+            _super.prototype.disconnect.call(this);
+        };
+        /**
+         * Called when new or updated config is supplied to the wire adapter.
+         *
+         * @param config new config parameters for the wire adapter
+         * @param context context for the wire adapter
+         */
+        LWCInfinteScrollingLuvioWireAdapter.prototype.update = function (config, context) {
+            if (this.connectTimestamp) {
+                var mergedContext = Object.assign({
+                    cachePolicy: {
+                        type: 'valid-at',
+                        timestamp: this.connectTimestamp,
+                    },
+                }, context);
+                _super.prototype.unsubscribe.call(this);
+                this.config = sanitize(config);
+                this.callAdapterWithContext(mergedContext);
+            }
+            else {
+                _super.prototype.update.call(this, config, context);
+            }
+        };
+        /**
+         * Calls the adapter if config has been set and the component is connected.
+         */
+        LWCInfinteScrollingLuvioWireAdapter.prototype.callAdapterWithContext = function (context) {
+            if (!this.connected || this.config === undefined) {
+                return;
+            }
+            var snapshotOrPromise = this.adapter(this.config, context);
+            _super.prototype.processAdapterResponse.call(this, snapshotOrPromise);
+        };
+        return LWCInfinteScrollingLuvioWireAdapter;
+    }(LWCLuvioWireAdapter));
+    function createInfiniteScrollingWireAdapterConstructor(adapter, name, luvio) {
+        var constructor = function (callback) {
+            var delegate = new LWCInfinteScrollingLuvioWireAdapter(adapter, name, luvio, callback);
+            this.connect = function () { return delegate.connect(); };
+            this.disconnect = function () { return delegate.disconnect(); };
+            this.update = function (config, context) {
+                return delegate.update(config, context);
+            };
+        };
+        Object.defineProperty(constructor, 'name', { value: name });
+        return constructor;
     }
 
-    function snapshotToPayload(snapshot) {
-        var payload = {
-            data: undefined,
-            errors: undefined,
-        };
-        if (snapshot === undefined) {
-            return payload;
-        }
-        payload.data = extractSnapshotData(snapshot);
-        // TODO handle batch error scenarios.
-        if ('error' in snapshot && snapshot.error !== undefined) {
-            if (Array.isArray(snapshot.error)) {
-                payload.errors = snapshot.error;
-            }
-            else {
-                payload.errors = [snapshot.error];
-            }
-        }
-        return payload;
-    }
-    var LWCGraphQLLuvioWireAdapter = /** @class */ (function (_super) {
-        __extends(LWCGraphQLLuvioWireAdapter, _super);
-        function LWCGraphQLLuvioWireAdapter(adapter, name, luvio, astResolver, callback) {
-            var _this = _super.call(this, adapter, name, luvio, callback) || this;
-            _this.astResolver = astResolver;
-            return _this;
-        }
-        LWCGraphQLLuvioWireAdapter.prototype.update = function (config, _context) {
-            this.unsubscribe();
-            if (config.batchQuery) {
-                this.config = {
-                    batchQuery: config.batchQuery.map(function (individualConfig) {
-                        return safeSanitizeGraphQLConfigObject(individualConfig);
-                    }),
-                };
-            }
-            else {
-                this.config = safeSanitizeGraphQLConfigObject(config);
-            }
-            this.callAdapter();
-        };
-        /**
-         * Emits new values to the callback.
-         *
-         * @param snapshot Snapshot to be emitted, if omitted then undefineds will be emitted
-         */
-        LWCGraphQLLuvioWireAdapter.prototype.emit = function (snapshot) {
-            var payload = snapshotToPayload(snapshot);
-            dataToTupleWeakMap.set(payload, [this.name, snapshot]);
-            try {
-                this.callback(payload);
-            }
-            catch (error) {
-                if (error instanceof Error) {
-                    throwAnnotatedError(error, USERLAND_PROVISION_ERROR_MESSAGE);
-                }
-            }
-        };
-        /**
-         * Coerce config before calling the adapter, preserve current behavior otherwise
-         */
-        LWCGraphQLLuvioWireAdapter.prototype.callAdapter = function () {
-            var _this = this;
-            if (!this.connected || this.config === undefined) {
-                return;
-            }
-            var config = this.config;
-            if ('batchQuery' in config) {
-                var batchConfig = {
-                    batchQuery: config.batchQuery.map(function (individualConfig) {
-                        return _this.resolveQueryAst(individualConfig);
-                    }),
-                };
-                // If any of the configurations are invalid, we bail out of calling the adapter.
-                if (batchConfig.batchQuery.some(function (val) { return val === undefined; })) {
-                    return;
-                }
-                var snapshotOrPromise = this.adapter(batchConfig);
-                this.processAdapterResponse(snapshotOrPromise);
-            }
-            else if ('query' in config) {
-                var singleConfig = this.resolveQueryAst(config);
-                if (singleConfig !== undefined) {
-                    var snapshotOrPromise = this.adapter(singleConfig);
-                    this.processAdapterResponse(snapshotOrPromise);
-                }
-            }
-        };
-        LWCGraphQLLuvioWireAdapter.prototype.resolveQueryAst = function (config) {
-            if (config.query === null) {
-                return;
-            }
-            var ast = this.astResolver(config.query);
-            if (ast === undefined && config.query !== undefined) {
-                // this should only happen if the user didn't parse the query
-                if (process.env.NODE_ENV !== 'production') {
-                    throw new Error(USERLAND_GRAPHQL_PARSER_ERROR_MESSAGE);
-                }
-                return;
-            }
-            var resolvedAdapterConfig = __assign(__assign({}, config), { query: ast });
-            return resolvedAdapterConfig;
-        };
-        return LWCGraphQLLuvioWireAdapter;
-    }(LWCLuvioWireAdapter));
-    function extractSnapshotData(snapshot) {
-        if ('data' in snapshot && snapshot.data !== undefined) {
-            var isSingleGraphQLData = 'data' in snapshot.data && snapshot.data.data !== undefined;
-            var isBatchGraphQLData = 'results' in snapshot.data && snapshot.data.results !== undefined;
-            if (isSingleGraphQLData)
-                return snapshot.data.data;
-            if (isBatchGraphQLData)
-                return snapshot.data;
-        }
-    }
-    /**
-     * Wraps a luvio Adapter in a WireAdapterConstructor that conforms to https://rfcs.lwc.dev/rfcs/lwc/0000-wire-reform#wire-adapter-protocol.
-     *
-     * @param adapter Adapter
-     * @param name name to assign to the generated constructor
-     * @param luvio Luvio
-     */
-    function createGraphQLWireAdapterConstructor(adapter, name, luvio, astResolver) {
-        var constructor = function (callback) {
-            var delegate = new LWCGraphQLLuvioWireAdapter(adapter, name, luvio, astResolver, callback);
-            this.connect = function () { return delegate.connect(); };
-            this.disconnect = function () { return delegate.disconnect(); };
-            this.update = function (config, context) {
-                return delegate.update(config, context);
-            };
-        };
-        Object.defineProperty(constructor, 'name', { value: name });
-        return constructor;
-    }
-    function safeSanitizeGraphQLConfigObject(config) {
-        // graphql query AST is passed by reference
-        // sanitizing it makes a copy and we lose that reference
-        // so we avoid sanitizing it
-        return __assign(__assign({}, sanitize(config)), { query: config.query });
+    function snapshotToPayload(snapshot) {
+        var payload = {
+            data: undefined,
+            errors: undefined,
+        };
+        if (snapshot === undefined) {
+            return payload;
+        }
+        payload.data = extractSnapshotData(snapshot);
+        // TODO handle batch error scenarios.
+        if ('error' in snapshot && snapshot.error !== undefined) {
+            if (Array.isArray(snapshot.error)) {
+                payload.errors = snapshot.error;
+            }
+            else {
+                payload.errors = [snapshot.error];
+            }
+        }
+        return payload;
+    }
+    var LWCGraphQLLuvioWireAdapter = /** @class */ (function (_super) {
+        __extends(LWCGraphQLLuvioWireAdapter, _super);
+        function LWCGraphQLLuvioWireAdapter(adapter, name, luvio, astResolver, callback) {
+            var _this = _super.call(this, adapter, name, luvio, callback) || this;
+            _this.astResolver = astResolver;
+            return _this;
+        }
+        LWCGraphQLLuvioWireAdapter.prototype.update = function (config, _context) {
+            this.unsubscribe();
+            if (config.batchQuery) {
+                this.config = {
+                    batchQuery: config.batchQuery.map(function (individualConfig) {
+                        return safeSanitizeGraphQLConfigObject(individualConfig);
+                    }),
+                };
+            }
+            else {
+                this.config = safeSanitizeGraphQLConfigObject(config);
+            }
+            this.callAdapter();
+        };
+        /**
+         * Emits new values to the callback.
+         *
+         * @param snapshot Snapshot to be emitted, if omitted then undefineds will be emitted
+         */
+        LWCGraphQLLuvioWireAdapter.prototype.emit = function (snapshot) {
+            var payload = snapshotToPayload(snapshot);
+            dataToTupleWeakMap.set(payload, [this.name, snapshot]);
+            try {
+                this.callback(payload);
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    throwAnnotatedError(error, USERLAND_PROVISION_ERROR_MESSAGE);
+                }
+            }
+        };
+        /**
+         * Coerce config before calling the adapter, preserve current behavior otherwise
+         */
+        LWCGraphQLLuvioWireAdapter.prototype.callAdapter = function () {
+            var _this = this;
+            if (!this.connected || this.config === undefined) {
+                return;
+            }
+            var config = this.config;
+            if ('batchQuery' in config) {
+                var batchConfig = {
+                    batchQuery: config.batchQuery.map(function (individualConfig) {
+                        return _this.resolveQueryAst(individualConfig);
+                    }),
+                };
+                // If any of the configurations are invalid, we bail out of calling the adapter.
+                if (batchConfig.batchQuery.some(function (val) { return val === undefined; })) {
+                    return;
+                }
+                var snapshotOrPromise = this.adapter(batchConfig);
+                this.processAdapterResponse(snapshotOrPromise);
+            }
+            else if ('query' in config) {
+                var singleConfig = this.resolveQueryAst(config);
+                if (singleConfig !== undefined) {
+                    var snapshotOrPromise = this.adapter(singleConfig);
+                    this.processAdapterResponse(snapshotOrPromise);
+                }
+            }
+        };
+        LWCGraphQLLuvioWireAdapter.prototype.resolveQueryAst = function (config) {
+            if (config.query === null) {
+                return;
+            }
+            var ast = this.astResolver(config.query);
+            if (ast === undefined && config.query !== undefined) {
+                // this should only happen if the user didn't parse the query
+                if (process.env.NODE_ENV !== 'production') {
+                    throw new Error(USERLAND_GRAPHQL_PARSER_ERROR_MESSAGE);
+                }
+                return;
+            }
+            var resolvedAdapterConfig = __assign(__assign({}, config), { query: ast });
+            return resolvedAdapterConfig;
+        };
+        return LWCGraphQLLuvioWireAdapter;
+    }(LWCLuvioWireAdapter));
+    function extractSnapshotData(snapshot) {
+        if ('data' in snapshot && snapshot.data !== undefined) {
+            var isSingleGraphQLData = 'data' in snapshot.data && snapshot.data.data !== undefined;
+            var isBatchGraphQLData = 'results' in snapshot.data && snapshot.data.results !== undefined;
+            if (isSingleGraphQLData)
+                return snapshot.data.data;
+            if (isBatchGraphQLData)
+                return snapshot.data;
+        }
+    }
+    /**
+     * Wraps a luvio Adapter in a WireAdapterConstructor that conforms to https://rfcs.lwc.dev/rfcs/lwc/0000-wire-reform#wire-adapter-protocol.
+     *
+     * @param adapter Adapter
+     * @param name name to assign to the generated constructor
+     * @param luvio Luvio
+     */
+    function createGraphQLWireAdapterConstructor(adapter, name, luvio, astResolver) {
+        var constructor = function (callback) {
+            var delegate = new LWCGraphQLLuvioWireAdapter(adapter, name, luvio, astResolver, callback);
+            this.connect = function () { return delegate.connect(); };
+            this.disconnect = function () { return delegate.disconnect(); };
+            this.update = function (config, context) {
+                return delegate.update(config, context);
+            };
+        };
+        Object.defineProperty(constructor, 'name', { value: name });
+        return constructor;
+    }
+    function safeSanitizeGraphQLConfigObject(config) {
+        // graphql query AST is passed by reference
+        // sanitizing it makes a copy and we lose that reference
+        // so we avoid sanitizing it
+        return __assign(__assign({}, sanitize(config)), { query: config.query });
     }
 
     exports.ADAPTER_UNFULFILLED_ERROR = ADAPTER_UNFULFILLED_ERROR;