@salesforce/lds-bindings 1.124.2 → 1.124.3

package/dist/ldsBindings.js

@@ -557,377 +557,377 @@ function safeSanitizeGraphQLConfigObject(config) {
     };
 }
 
-// For use by callers within this module to instrument interesting things.
-let instrumentation = {
-    refreshCalled: (_fromSource) => { },
-    instrumentAdapter: (adapter, _metadata) => {
-        return adapter;
-    },
-};
-/**
- * Allows external modules (typically a runtime environment) to set
- * instrumentation hooks for this module. Note that the hooks are
- * incremental - hooks not suppiled in newInstrumentation will retain
- * their previous values. The default instrumentation hooks are no-ops.
- *
- * @param newInstrumentation instrumentation hooks to be overridden
- */
-function instrument(newInstrumentation) {
-    instrumentation = Object.assign(instrumentation, newInstrumentation);
+// For use by callers within this module to instrument interesting things.
+let instrumentation = {
+    refreshCalled: (_fromSource) => { },
+    instrumentAdapter: (adapter, _metadata) => {
+        return adapter;
+    },
+};
+/**
+ * Allows external modules (typically a runtime environment) to set
+ * instrumentation hooks for this module. Note that the hooks are
+ * incremental - hooks not suppiled in newInstrumentation will retain
+ * their previous values. The default instrumentation hooks are no-ops.
+ *
+ * @param newInstrumentation instrumentation hooks to be overridden
+ */
+function instrument(newInstrumentation) {
+    instrumentation = Object.assign(instrumentation, newInstrumentation);
 }
 
-let refresh;
-function bindWireRefresh(luvio) {
-    const wireRefresh = bindWireRefresh$1(luvio);
-    refresh = (data, apiFamily) => {
-        instrumentation.refreshCalled(apiFamily);
-        return wireRefresh(data);
-    };
+let refresh;
+function bindWireRefresh(luvio) {
+    const wireRefresh = bindWireRefresh$1(luvio);
+    refresh = (data, apiFamily) => {
+        instrumentation.refreshCalled(apiFamily);
+        return wireRefresh(data);
+    };
 }
 
-function createInstrumentedAdapter(adapter, metadata) {
-    return instrumentation.instrumentAdapter(adapter, metadata);
+function createInstrumentedAdapter(adapter, metadata) {
+    return instrumentation.instrumentAdapter(adapter, metadata);
 }
 
-function createLDSAdapter(luvio, name, factory) {
-    return factory(luvio);
+function createLDSAdapter(luvio, name, factory) {
+    return factory(luvio);
 }
 
 const { create, defineProperty, defineProperties } = Object;
 
-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 isPendingSnapshot(snapshot) {
-    return snapshot.state === SnapshotState.Pending;
+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 isPendingSnapshot(snapshot) {
+    return snapshot.state === SnapshotState.Pending;
 }
 
-function isPromise(value) {
-    // check for Thenable due to test frameworks using custom Promise impls
-    return value !== null && value.then !== undefined;
+function isPromise(value) {
+    // check for Thenable due to test frameworks using custom Promise impls
+    return value !== null && value.then !== undefined;
 }
 
-function snapshotToTuple$1(snapshot) {
-    if (isErrorSnapshot(snapshot)) {
-        return {
-            data: undefined,
-            error: snapshot.error,
-        };
-    }
-    // We might still get pending snapshot here from invoke calls here
-    return {
-        data: snapshot.data,
-        error: undefined,
-    };
-}
-function createInvalidConfigError$1() {
-    return {
-        data: undefined,
-        error: {
-            ok: false,
-            status: 400,
-            statusText: 'INVALID_CONFIG',
-            body: undefined,
-            headers: {},
-            errorType: 'fetchResponse',
-        },
-    };
-}
-/**
- * Creates an imperative adapter
- *
- * @param luvio Luvio
- * @param adapter luvio adapter
- * @param metadata AdapterMetadata
- * @returns Imperative adapter object with invoke and subscribe functions
- */
-function createImperativeAdapter(luvio, adapter, metadata) {
-    const { name } = metadata;
-    const imperativeAdapterInvoke = (config, requestContext, callback) => {
-        const snapshotOrPromise = adapter(config, requestContext);
-        if (snapshotOrPromise === null) {
-            callback(createInvalidConfigError$1());
-            return;
-        }
-        if (!isPromise(snapshotOrPromise)) {
-            callback(snapshotToTuple$1(snapshotOrPromise));
-            return;
-        }
-        snapshotOrPromise.then((snapshot) => {
-            if (snapshot === null) {
-                callback(createInvalidConfigError$1());
-                return;
-            }
-            callback(snapshotToTuple$1(snapshot));
-        });
-    };
-    defineProperty(imperativeAdapterInvoke, 'name', {
-        value: `${name}_invoke`,
-    });
-    // Invokes the adapter and subscribes to the received snapshot
-    // Returns an unsubscribe function to the consumer
-    const imperativeAdapterSubscribe = (config, requestContext, callback) => {
-        let subscriberCallback = callback;
-        let unsub;
-        const snapshotOrPromise = adapter(config, requestContext);
-        if (snapshotOrPromise === null) {
-            subscriberCallback(createInvalidConfigError$1());
-            return () => { };
-        }
-        // Can rebuild lead to pending snapshots?
-        const luvioStoreSubscribe = (snapshot) => {
-            unsub = luvio.storeSubscribe(snapshot, (snapshotFromRebuild) => {
-                if (subscriberCallback !== null && !isPendingSnapshot(snapshotFromRebuild)) {
-                    subscriberCallback(snapshotToTuple$1(snapshotFromRebuild));
-                }
-            });
-        };
-        if (!isPromise(snapshotOrPromise)) {
-            // We don't want to return pending snapshots to user-land
-            // Instead we just subscribe to it
-            if (!isPendingSnapshot(snapshotOrPromise)) {
-                subscriberCallback(snapshotToTuple$1(snapshotOrPromise));
-            }
-            luvioStoreSubscribe(snapshotOrPromise);
-        }
-        else {
-            snapshotOrPromise.then((snapshot) => {
-                if (subscriberCallback !== null) {
-                    if (snapshot === null) {
-                        subscriberCallback(createInvalidConfigError$1());
-                        return;
-                    }
-                    // We don't want to return pending snapshots to user-land
-                    // Instead we just subscribe to it
-                    if (!isPendingSnapshot(snapshot)) {
-                        subscriberCallback(snapshotToTuple$1(snapshot));
-                    }
-                    luvioStoreSubscribe(snapshot);
-                }
-            });
-        }
-        return () => {
-            if (subscriberCallback !== null && unsub !== undefined) {
-                unsub();
-            }
-            subscriberCallback = null;
-            unsub = undefined;
-        };
-    };
-    defineProperty(imperativeAdapterSubscribe, 'name', {
-        value: `${name}_subscribe`,
-    });
-    return {
-        invoke: imperativeAdapterInvoke,
-        subscribe: imperativeAdapterSubscribe,
-    };
+function snapshotToTuple$1(snapshot) {
+    if (isErrorSnapshot(snapshot)) {
+        return {
+            data: undefined,
+            error: snapshot.error,
+        };
+    }
+    // We might still get pending snapshot here from invoke calls here
+    return {
+        data: snapshot.data,
+        error: undefined,
+    };
+}
+function createInvalidConfigError$1() {
+    return {
+        data: undefined,
+        error: {
+            ok: false,
+            status: 400,
+            statusText: 'INVALID_CONFIG',
+            body: undefined,
+            headers: {},
+            errorType: 'fetchResponse',
+        },
+    };
+}
+/**
+ * Creates an imperative adapter
+ *
+ * @param luvio Luvio
+ * @param adapter luvio adapter
+ * @param metadata AdapterMetadata
+ * @returns Imperative adapter object with invoke and subscribe functions
+ */
+function createImperativeAdapter(luvio, adapter, metadata) {
+    const { name } = metadata;
+    const imperativeAdapterInvoke = (config, requestContext, callback) => {
+        const snapshotOrPromise = adapter(config, requestContext);
+        if (snapshotOrPromise === null) {
+            callback(createInvalidConfigError$1());
+            return;
+        }
+        if (!isPromise(snapshotOrPromise)) {
+            callback(snapshotToTuple$1(snapshotOrPromise));
+            return;
+        }
+        snapshotOrPromise.then((snapshot) => {
+            if (snapshot === null) {
+                callback(createInvalidConfigError$1());
+                return;
+            }
+            callback(snapshotToTuple$1(snapshot));
+        });
+    };
+    defineProperty(imperativeAdapterInvoke, 'name', {
+        value: `${name}_invoke`,
+    });
+    // Invokes the adapter and subscribes to the received snapshot
+    // Returns an unsubscribe function to the consumer
+    const imperativeAdapterSubscribe = (config, requestContext, callback) => {
+        let subscriberCallback = callback;
+        let unsub;
+        const snapshotOrPromise = adapter(config, requestContext);
+        if (snapshotOrPromise === null) {
+            subscriberCallback(createInvalidConfigError$1());
+            return () => { };
+        }
+        // Can rebuild lead to pending snapshots?
+        const luvioStoreSubscribe = (snapshot) => {
+            unsub = luvio.storeSubscribe(snapshot, (snapshotFromRebuild) => {
+                if (subscriberCallback !== null && !isPendingSnapshot(snapshotFromRebuild)) {
+                    subscriberCallback(snapshotToTuple$1(snapshotFromRebuild));
+                }
+            });
+        };
+        if (!isPromise(snapshotOrPromise)) {
+            // We don't want to return pending snapshots to user-land
+            // Instead we just subscribe to it
+            if (!isPendingSnapshot(snapshotOrPromise)) {
+                subscriberCallback(snapshotToTuple$1(snapshotOrPromise));
+            }
+            luvioStoreSubscribe(snapshotOrPromise);
+        }
+        else {
+            snapshotOrPromise.then((snapshot) => {
+                if (subscriberCallback !== null) {
+                    if (snapshot === null) {
+                        subscriberCallback(createInvalidConfigError$1());
+                        return;
+                    }
+                    // We don't want to return pending snapshots to user-land
+                    // Instead we just subscribe to it
+                    if (!isPendingSnapshot(snapshot)) {
+                        subscriberCallback(snapshotToTuple$1(snapshot));
+                    }
+                    luvioStoreSubscribe(snapshot);
+                }
+            });
+        }
+        return () => {
+            if (subscriberCallback !== null && unsub !== undefined) {
+                unsub();
+            }
+            subscriberCallback = null;
+            unsub = undefined;
+        };
+    };
+    defineProperty(imperativeAdapterSubscribe, 'name', {
+        value: `${name}_subscribe`,
+    });
+    return {
+        invoke: imperativeAdapterInvoke,
+        subscribe: imperativeAdapterSubscribe,
+    };
 }
 
-function snapshotToTuple(snapshot) {
-    if (isErrorSnapshot(snapshot)) {
-        if (snapshot.error.errorType === 'adapterError') {
-            // GraphQL can return 200 with an errors array
-            return {
-                data: undefined,
-                errors: snapshot.error.error,
-            };
-        }
-        else {
-            // This is a network error or some other error - usually with a single error bubled up.
-            return {
-                data: undefined,
-                errors: [snapshot.error],
-            };
-        }
-    }
-    // cast any PendingSnapshot to FulfilledSnapshot here,
-    //  we shouldn't get anything pending at this point
-    const payload = {};
-    const dataSnapshot = snapshot;
-    if ('data' in dataSnapshot.data && dataSnapshot.data.data !== undefined) {
-        payload.data = dataSnapshot.data.data;
-    }
-    if (dataSnapshot.data.errors !== undefined) {
-        payload.errors = dataSnapshot.data.errors;
-    }
-    return payload;
-}
-function createInvalidConfigError() {
-    return {
-        data: undefined,
-        errors: [
-            {
-                ok: false,
-                status: 400,
-                statusText: 'INVALID_CONFIG',
-                body: undefined,
-                headers: {},
-                errorType: 'fetchResponse',
-            },
-        ],
-    };
-}
-/**
- * Creates an imperative adapter
- *
- * @param luvio Luvio
- * @param adapter luvio adapter
- * @param metadata AdapterMetadata
- * @returns Imperative adapter object with invoke and subscribe functions
- */
-function createGraphQLImperativeAdapter(luvio, adapter, metadata, astResolver) {
-    const { name } = metadata;
-    const imperativeAdapterInvoke = (config, requestContext, callback) => {
-        let coercedConfig = null;
-        if ('batchQuery' in config) {
-            coercedConfig = {
-                batchQuery: config.batchQuery.map((individualConfig) => ({
-                    ...individualConfig,
-                    query: astResolver(individualConfig.query),
-                })),
-            };
-            // If any of the configurations are invalid, we bail out of calling the adapter.
-            if (coercedConfig.batchQuery.some((individualConfig) => individualConfig.query === undefined)) {
-                callback(createInvalidConfigError());
-                return;
-            }
-        }
-        else if ('query' in config) {
-            const ast = astResolver(config.query);
-            if (ast === undefined) {
-                callback(createInvalidConfigError());
-                return;
-            }
-            coercedConfig = {
-                ...config,
-                query: ast,
-            };
-        }
-        const snapshotOrPromise = adapter(coercedConfig, requestContext);
-        if (snapshotOrPromise === null) {
-            callback(createInvalidConfigError());
-            return;
-        }
-        if (!isPromise(snapshotOrPromise)) {
-            callback(snapshotToTuple(snapshotOrPromise));
-            return;
-        }
-        snapshotOrPromise.then((snapshot) => {
-            if (snapshot === null) {
-                callback(createInvalidConfigError());
-                return;
-            }
-            callback(snapshotToTuple(snapshot));
-        });
-    };
-    defineProperty(imperativeAdapterInvoke, 'name', {
-        value: `${name}_invoke`,
-    });
-    // Invokes the adapter and subscribes to the received snapshot
-    // Returns an unsubscribe function to the consumer
-    const imperativeAdapterSubscribe = (config, requestContext, callback) => {
-        let subscriberCallback = callback;
-        let unsub;
-        let coercedConfig = null;
-        if ('batchQuery' in config) {
-            coercedConfig = {
-                batchQuery: config.batchQuery.map((individualConfig) => ({
-                    ...individualConfig,
-                    query: astResolver(individualConfig.query),
-                })),
-            };
-            // If any of the configurations are invalid, we bail out of calling the adapter.
-            if (coercedConfig.batchQuery.some((individualConfig) => individualConfig.query === undefined)) {
-                callback(createInvalidConfigError());
-                return () => { };
-            }
-        }
-        else if ('query' in config) {
-            const ast = astResolver(config.query);
-            if (ast === undefined) {
-                callback(createInvalidConfigError());
-                return () => { };
-            }
-            coercedConfig = {
-                ...config,
-                query: ast,
-            };
-        }
-        const snapshotOrPromise = adapter(coercedConfig, requestContext);
-        if (snapshotOrPromise === null) {
-            subscriberCallback(createInvalidConfigError());
-            return () => { };
-        }
-        // Can rebuild lead to pending snapshots?
-        const luvioStoreSubscribe = (snapshot) => {
-            unsub = luvio.storeSubscribe(snapshot, (snapshotFromRebuild) => {
-                if (subscriberCallback !== null && !isPendingSnapshot(snapshotFromRebuild)) {
-                    subscriberCallback(snapshotToTuple(snapshotFromRebuild));
-                }
-            });
-        };
-        if (!isPromise(snapshotOrPromise)) {
-            // We don't want to return pending snapshots to user-land
-            // Instead we just subscribe to it
-            if (!isPendingSnapshot(snapshotOrPromise)) {
-                subscriberCallback(snapshotToTuple(snapshotOrPromise));
-            }
-            luvioStoreSubscribe(snapshotOrPromise);
-        }
-        else {
-            snapshotOrPromise.then((snapshot) => {
-                if (subscriberCallback !== null) {
-                    if (snapshot === null) {
-                        subscriberCallback(createInvalidConfigError());
-                        return;
-                    }
-                    // TODO [W-11370904]: revisit this. Does GraphQL need to worry about pending?
-                    // We don't want to return pending snapshots to user-land
-                    // Instead we just subscribe to it
-                    if (!isPendingSnapshot(snapshot)) {
-                        subscriberCallback(snapshotToTuple(snapshot));
-                    }
-                    luvioStoreSubscribe(snapshot);
-                }
-            });
-        }
-        return () => {
-            if (subscriberCallback !== null && unsub !== undefined) {
-                unsub();
-            }
-            subscriberCallback = null;
-            unsub = undefined;
-        };
-    };
-    defineProperty(imperativeAdapterSubscribe, 'name', {
-        value: `${name}_subscribe`,
-    });
-    return {
-        invoke: imperativeAdapterInvoke,
-        subscribe: imperativeAdapterSubscribe,
-    };
+function snapshotToTuple(snapshot) {
+    if (isErrorSnapshot(snapshot)) {
+        if (snapshot.error.errorType === 'adapterError') {
+            // GraphQL can return 200 with an errors array
+            return {
+                data: undefined,
+                errors: snapshot.error.error,
+            };
+        }
+        else {
+            // This is a network error or some other error - usually with a single error bubled up.
+            return {
+                data: undefined,
+                errors: [snapshot.error],
+            };
+        }
+    }
+    // cast any PendingSnapshot to FulfilledSnapshot here,
+    //  we shouldn't get anything pending at this point
+    const payload = {};
+    const dataSnapshot = snapshot;
+    if ('data' in dataSnapshot.data && dataSnapshot.data.data !== undefined) {
+        payload.data = dataSnapshot.data.data;
+    }
+    if (dataSnapshot.data.errors !== undefined) {
+        payload.errors = dataSnapshot.data.errors;
+    }
+    return payload;
+}
+function createInvalidConfigError() {
+    return {
+        data: undefined,
+        errors: [
+            {
+                ok: false,
+                status: 400,
+                statusText: 'INVALID_CONFIG',
+                body: undefined,
+                headers: {},
+                errorType: 'fetchResponse',
+            },
+        ],
+    };
+}
+/**
+ * Creates an imperative adapter
+ *
+ * @param luvio Luvio
+ * @param adapter luvio adapter
+ * @param metadata AdapterMetadata
+ * @returns Imperative adapter object with invoke and subscribe functions
+ */
+function createGraphQLImperativeAdapter(luvio, adapter, metadata, astResolver) {
+    const { name } = metadata;
+    const imperativeAdapterInvoke = (config, requestContext, callback) => {
+        let coercedConfig = null;
+        if ('batchQuery' in config) {
+            coercedConfig = {
+                batchQuery: config.batchQuery.map((individualConfig) => ({
+                    ...individualConfig,
+                    query: astResolver(individualConfig.query),
+                })),
+            };
+            // If any of the configurations are invalid, we bail out of calling the adapter.
+            if (coercedConfig.batchQuery.some((individualConfig) => individualConfig.query === undefined)) {
+                callback(createInvalidConfigError());
+                return;
+            }
+        }
+        else if ('query' in config) {
+            const ast = astResolver(config.query);
+            if (ast === undefined) {
+                callback(createInvalidConfigError());
+                return;
+            }
+            coercedConfig = {
+                ...config,
+                query: ast,
+            };
+        }
+        const snapshotOrPromise = adapter(coercedConfig, requestContext);
+        if (snapshotOrPromise === null) {
+            callback(createInvalidConfigError());
+            return;
+        }
+        if (!isPromise(snapshotOrPromise)) {
+            callback(snapshotToTuple(snapshotOrPromise));
+            return;
+        }
+        snapshotOrPromise.then((snapshot) => {
+            if (snapshot === null) {
+                callback(createInvalidConfigError());
+                return;
+            }
+            callback(snapshotToTuple(snapshot));
+        });
+    };
+    defineProperty(imperativeAdapterInvoke, 'name', {
+        value: `${name}_invoke`,
+    });
+    // Invokes the adapter and subscribes to the received snapshot
+    // Returns an unsubscribe function to the consumer
+    const imperativeAdapterSubscribe = (config, requestContext, callback) => {
+        let subscriberCallback = callback;
+        let unsub;
+        let coercedConfig = null;
+        if ('batchQuery' in config) {
+            coercedConfig = {
+                batchQuery: config.batchQuery.map((individualConfig) => ({
+                    ...individualConfig,
+                    query: astResolver(individualConfig.query),
+                })),
+            };
+            // If any of the configurations are invalid, we bail out of calling the adapter.
+            if (coercedConfig.batchQuery.some((individualConfig) => individualConfig.query === undefined)) {
+                callback(createInvalidConfigError());
+                return () => { };
+            }
+        }
+        else if ('query' in config) {
+            const ast = astResolver(config.query);
+            if (ast === undefined) {
+                callback(createInvalidConfigError());
+                return () => { };
+            }
+            coercedConfig = {
+                ...config,
+                query: ast,
+            };
+        }
+        const snapshotOrPromise = adapter(coercedConfig, requestContext);
+        if (snapshotOrPromise === null) {
+            subscriberCallback(createInvalidConfigError());
+            return () => { };
+        }
+        // Can rebuild lead to pending snapshots?
+        const luvioStoreSubscribe = (snapshot) => {
+            unsub = luvio.storeSubscribe(snapshot, (snapshotFromRebuild) => {
+                if (subscriberCallback !== null && !isPendingSnapshot(snapshotFromRebuild)) {
+                    subscriberCallback(snapshotToTuple(snapshotFromRebuild));
+                }
+            });
+        };
+        if (!isPromise(snapshotOrPromise)) {
+            // We don't want to return pending snapshots to user-land
+            // Instead we just subscribe to it
+            if (!isPendingSnapshot(snapshotOrPromise)) {
+                subscriberCallback(snapshotToTuple(snapshotOrPromise));
+            }
+            luvioStoreSubscribe(snapshotOrPromise);
+        }
+        else {
+            snapshotOrPromise.then((snapshot) => {
+                if (subscriberCallback !== null) {
+                    if (snapshot === null) {
+                        subscriberCallback(createInvalidConfigError());
+                        return;
+                    }
+                    // TODO [W-11370904]: revisit this. Does GraphQL need to worry about pending?
+                    // We don't want to return pending snapshots to user-land
+                    // Instead we just subscribe to it
+                    if (!isPendingSnapshot(snapshot)) {
+                        subscriberCallback(snapshotToTuple(snapshot));
+                    }
+                    luvioStoreSubscribe(snapshot);
+                }
+            });
+        }
+        return () => {
+            if (subscriberCallback !== null && unsub !== undefined) {
+                unsub();
+            }
+            subscriberCallback = null;
+            unsub = undefined;
+        };
+    };
+    defineProperty(imperativeAdapterSubscribe, 'name', {
+        value: `${name}_subscribe`,
+    });
+    return {
+        invoke: imperativeAdapterInvoke,
+        subscribe: imperativeAdapterSubscribe,
+    };
 }
 
-function createWireAdapterConstructor(luvio, adapter, metadata) {
-    const { apiFamily, name } = metadata;
-    return createWireAdapterConstructor$1(adapter, `${apiFamily}.${name}`, luvio);
-}
-function createInfiniteScrollingWireAdapterConstructor(luvio, adapter, metadata) {
-    const { apiFamily, name } = metadata;
-    return createInfiniteScrollingWireAdapterConstructor$1(adapter, `${apiFamily}.${name}`, luvio);
-}
-function createGraphQLWireAdapterConstructor(luvio, adapter, metadata, astResolver) {
-    const { apiFamily, name } = metadata;
-    return createGraphQLWireAdapterConstructor$1(adapter, `${apiFamily}.${name}`, luvio, astResolver);
+function createWireAdapterConstructor(luvio, adapter, metadata) {
+    const { apiFamily, name } = metadata;
+    return createWireAdapterConstructor$1(adapter, `${apiFamily}.${name}`, luvio);
+}
+function createInfiniteScrollingWireAdapterConstructor(luvio, adapter, metadata) {
+    const { apiFamily, name } = metadata;
+    return createInfiniteScrollingWireAdapterConstructor$1(adapter, `${apiFamily}.${name}`, luvio);
+}
+function createGraphQLWireAdapterConstructor(luvio, adapter, metadata, astResolver) {
+    const { apiFamily, name } = metadata;
+    return createGraphQLWireAdapterConstructor$1(adapter, `${apiFamily}.${name}`, luvio, astResolver);
 }
 
 export { ADAPTER_UNFULFILLED_ERROR, REFRESH_ADAPTER_EVENT, bindWireRefresh, createGraphQLImperativeAdapter, createGraphQLWireAdapterConstructor, createImperativeAdapter, createInfiniteScrollingWireAdapterConstructor, createInstrumentedAdapter, createLDSAdapter, createWireAdapterConstructor, instrument, refresh };
-// version: 1.124.2-a5418d550
+// version: 1.124.3-cf2dbb2fa

package/dist/{bindWireRefresh.d.ts → types/bindWireRefresh.d.ts}

@@ -1,7 +1,7 @@
-import type { Luvio } from '@luvio/engine';
-export type refreshApiNames = {
-    refreshApex: string;
-    refreshUiApi: string;
-};
-export declare let refresh: (data: any, apiFamily: keyof refreshApiNames) => Promise<undefined> | undefined;
-export declare function bindWireRefresh(luvio: Luvio): void;
+import type { Luvio } from '@luvio/engine';
+export type refreshApiNames = {
+    refreshApex: string;
+    refreshUiApi: string;
+};
+export declare let refresh: (data: any, apiFamily: keyof refreshApiNames) => Promise<undefined> | undefined;
+export declare function bindWireRefresh(luvio: Luvio): void;

package/dist/{constants.d.ts → types/constants.d.ts}

@@ -1 +1 @@
-export { REFRESH_ADAPTER_EVENT, ADAPTER_UNFULFILLED_ERROR } from '@luvio/lwc-luvio';
+export { REFRESH_ADAPTER_EVENT, ADAPTER_UNFULFILLED_ERROR } from '@luvio/lwc-luvio';

package/dist/{graphQLImperativeAdapter.d.ts → types/graphQLImperativeAdapter.d.ts}

@@ -1,32 +1,32 @@
-import type { Adapter, AdapterRequestContext, ErrorResponse as LuvioErrorResponse, Luvio, Unsubscribe } from '@luvio/engine';
-import type { AstResolver } from '@luvio/graphql-parser';
-import type { GraphQLError, GraphQLInput } from '@luvio/lwc-luvio';
-import type { AdapterMetadata } from './ldsAdapter';
-interface DataResponse {
-    data: any;
-    errors?: GraphQLError[];
-}
-interface ErrorResponse {
-    data: undefined;
-    errors: LuvioErrorResponse[];
-}
-type DataCallbackTuple = DataResponse | ErrorResponse;
-interface DataCallback {
-    (response: DataCallbackTuple): void;
-}
-type ImperativeAdapterInvokeType<C> = (config: C, context: AdapterRequestContext, callback: DataCallback) => void;
-type ImperativeAdapterSubscribeType<C> = (config: C, context: AdapterRequestContext, callback: DataCallback) => Unsubscribe;
-interface ImperativeAdapter<C> {
-    invoke: ImperativeAdapterInvokeType<C>;
-    subscribe: ImperativeAdapterSubscribeType<C>;
-}
-/**
- * Creates an imperative adapter
- *
- * @param luvio Luvio
- * @param adapter luvio adapter
- * @param metadata AdapterMetadata
- * @returns Imperative adapter object with invoke and subscribe functions
- */
-export declare function createGraphQLImperativeAdapter<C extends GraphQLInput, D>(luvio: Luvio, adapter: Adapter<C, D>, metadata: AdapterMetadata, astResolver: AstResolver): ImperativeAdapter<C>;
-export {};
+import type { Adapter, AdapterRequestContext, ErrorResponse as LuvioErrorResponse, Luvio, Unsubscribe } from '@luvio/engine';
+import type { AstResolver } from '@luvio/graphql-parser';
+import type { GraphQLError, GraphQLInput } from '@luvio/lwc-luvio';
+import type { AdapterMetadata } from './ldsAdapter';
+interface DataResponse {
+    data: any;
+    errors?: GraphQLError[];
+}
+interface ErrorResponse {
+    data: undefined;
+    errors: LuvioErrorResponse[];
+}
+type DataCallbackTuple = DataResponse | ErrorResponse;
+interface DataCallback {
+    (response: DataCallbackTuple): void;
+}
+type ImperativeAdapterInvokeType<C> = (config: C, context: AdapterRequestContext, callback: DataCallback) => void;
+type ImperativeAdapterSubscribeType<C> = (config: C, context: AdapterRequestContext, callback: DataCallback) => Unsubscribe;
+interface ImperativeAdapter<C> {
+    invoke: ImperativeAdapterInvokeType<C>;
+    subscribe: ImperativeAdapterSubscribeType<C>;
+}
+/**
+ * Creates an imperative adapter
+ *
+ * @param luvio Luvio
+ * @param adapter luvio adapter
+ * @param metadata AdapterMetadata
+ * @returns Imperative adapter object with invoke and subscribe functions
+ */
+export declare function createGraphQLImperativeAdapter<C extends GraphQLInput, D>(luvio: Luvio, adapter: Adapter<C, D>, metadata: AdapterMetadata, astResolver: AstResolver): ImperativeAdapter<C>;
+export {};

package/dist/{imperativeAdapter.d.ts → types/imperativeAdapter.d.ts}

@@ -1,31 +1,31 @@
-import type { Adapter, AdapterRequestContext, ErrorResponse as LuvioErrorResponse, Luvio, Snapshot, StaleSnapshot, UnfulfilledSnapshot, Unsubscribe } from '@luvio/engine';
-import type { AdapterMetadata } from './ldsAdapter';
-interface DataResponse<D> {
-    data: D;
-    error: undefined;
-}
-interface ErrorResponse {
-    data: undefined;
-    error: LuvioErrorResponse;
-}
-export type DataCallbackTuple<D> = DataResponse<D> | ErrorResponse;
-export type CallbackSnapshot<D> = Exclude<Snapshot<D>, UnfulfilledSnapshot<D> | StaleSnapshot<D>>;
-export interface DataCallback<D> {
-    (response: DataCallbackTuple<D>): void;
-}
-type ImperativeAdapterInvokeType<C, D> = (config: C, context: AdapterRequestContext | undefined, callback: DataCallback<D>) => void;
-type ImperativeAdapterSubscribeType<C, D> = (config: C, context: AdapterRequestContext | undefined, callback: DataCallback<D>) => Unsubscribe;
-export interface ImperativeAdapter<C, D> {
-    invoke: ImperativeAdapterInvokeType<C, D>;
-    subscribe: ImperativeAdapterSubscribeType<C, D>;
-}
-/**
- * Creates an imperative adapter
- *
- * @param luvio Luvio
- * @param adapter luvio adapter
- * @param metadata AdapterMetadata
- * @returns Imperative adapter object with invoke and subscribe functions
- */
-export declare function createImperativeAdapter<C, D>(luvio: Luvio, adapter: Adapter<C, D>, metadata: AdapterMetadata): ImperativeAdapter<C, D>;
-export {};
+import type { Adapter, AdapterRequestContext, ErrorResponse as LuvioErrorResponse, Luvio, Snapshot, StaleSnapshot, UnfulfilledSnapshot, Unsubscribe } from '@luvio/engine';
+import type { AdapterMetadata } from './ldsAdapter';
+interface DataResponse<D> {
+    data: D;
+    error: undefined;
+}
+interface ErrorResponse {
+    data: undefined;
+    error: LuvioErrorResponse;
+}
+export type DataCallbackTuple<D> = DataResponse<D> | ErrorResponse;
+export type CallbackSnapshot<D> = Exclude<Snapshot<D>, UnfulfilledSnapshot<D> | StaleSnapshot<D>>;
+export interface DataCallback<D> {
+    (response: DataCallbackTuple<D>): void;
+}
+type ImperativeAdapterInvokeType<C, D> = (config: C, context: AdapterRequestContext | undefined, callback: DataCallback<D>) => void;
+type ImperativeAdapterSubscribeType<C, D> = (config: C, context: AdapterRequestContext | undefined, callback: DataCallback<D>) => Unsubscribe;
+export interface ImperativeAdapter<C, D> {
+    invoke: ImperativeAdapterInvokeType<C, D>;
+    subscribe: ImperativeAdapterSubscribeType<C, D>;
+}
+/**
+ * Creates an imperative adapter
+ *
+ * @param luvio Luvio
+ * @param adapter luvio adapter
+ * @param metadata AdapterMetadata
+ * @returns Imperative adapter object with invoke and subscribe functions
+ */
+export declare function createImperativeAdapter<C, D>(luvio: Luvio, adapter: Adapter<C, D>, metadata: AdapterMetadata): ImperativeAdapter<C, D>;
+export {};

package/dist/{instrumentation.d.ts → types/instrumentation.d.ts}

@@ -1,29 +1,29 @@
-import type { Adapter } from '@luvio/engine';
-import type { AdapterMetadata } from './ldsAdapter';
-import type { refreshApiNames } from './bindWireRefresh';
-/**
- * Instrumentation hooks exposed by this module.
- */
-export interface LwcBindingsInstrumentation {
-    /**
-     * Called when an LWC calls `refresh`.
-     */
-    refreshCalled?: (fromSource: keyof refreshApiNames) => void;
-    /**
-     * Called when creating wire adapters.
-     */
-    instrumentAdapter?: <C, D>(adapter: Adapter<C, D>, metadata: AdapterMetadata) => Adapter<C, D>;
-}
-export declare let instrumentation: {
-    refreshCalled: (_fromSource: keyof refreshApiNames) => void;
-    instrumentAdapter: <C, D>(adapter: Adapter<C, D>, _metadata: AdapterMetadata) => Adapter<C, D>;
-};
-/**
- * Allows external modules (typically a runtime environment) to set
- * instrumentation hooks for this module. Note that the hooks are
- * incremental - hooks not suppiled in newInstrumentation will retain
- * their previous values. The default instrumentation hooks are no-ops.
- *
- * @param newInstrumentation instrumentation hooks to be overridden
- */
-export declare function instrument(newInstrumentation: LwcBindingsInstrumentation): void;
+import type { Adapter } from '@luvio/engine';
+import type { AdapterMetadata } from './ldsAdapter';
+import type { refreshApiNames } from './bindWireRefresh';
+/**
+ * Instrumentation hooks exposed by this module.
+ */
+export interface LwcBindingsInstrumentation {
+    /**
+     * Called when an LWC calls `refresh`.
+     */
+    refreshCalled?: (fromSource: keyof refreshApiNames) => void;
+    /**
+     * Called when creating wire adapters.
+     */
+    instrumentAdapter?: <C, D>(adapter: Adapter<C, D>, metadata: AdapterMetadata) => Adapter<C, D>;
+}
+export declare let instrumentation: {
+    refreshCalled: (_fromSource: keyof refreshApiNames) => void;
+    instrumentAdapter: <C, D>(adapter: Adapter<C, D>, _metadata: AdapterMetadata) => Adapter<C, D>;
+};
+/**
+ * Allows external modules (typically a runtime environment) to set
+ * instrumentation hooks for this module. Note that the hooks are
+ * incremental - hooks not suppiled in newInstrumentation will retain
+ * their previous values. The default instrumentation hooks are no-ops.
+ *
+ * @param newInstrumentation instrumentation hooks to be overridden
+ */
+export declare function instrument(newInstrumentation: LwcBindingsInstrumentation): void;

package/dist/{instrumentedAdapter.d.ts → types/instrumentedAdapter.d.ts}

@@ -1,3 +1,3 @@
-import type { Adapter } from '@luvio/engine';
-import type { AdapterMetadata } from './ldsAdapter';
-export declare function createInstrumentedAdapter<C, D>(adapter: Adapter<C, D>, metadata: AdapterMetadata): Adapter<C, D>;
+import type { Adapter } from '@luvio/engine';
+import type { AdapterMetadata } from './ldsAdapter';
+export declare function createInstrumentedAdapter<C, D>(adapter: Adapter<C, D>, metadata: AdapterMetadata): Adapter<C, D>;

package/dist/{ldsAdapter.d.ts → types/ldsAdapter.d.ts}

@@ -1,7 +1,7 @@
-import type { Luvio } from '@luvio/engine';
-export interface AdapterMetadata {
-    apiFamily: string;
-    name: string;
-    ttl?: number;
-}
-export declare function createLDSAdapter<T>(luvio: Luvio, name: string, factory: (luvio: Luvio) => T): T;
+import type { Luvio } from '@luvio/engine';
+export interface AdapterMetadata {
+    apiFamily: string;
+    name: string;
+    ttl?: number;
+}
+export declare function createLDSAdapter<T>(luvio: Luvio, name: string, factory: (luvio: Luvio) => T): T;

package/dist/{main.d.ts → types/main.d.ts}

@@ -1,9 +1,9 @@
-export { bindWireRefresh, refresh } from './bindWireRefresh';
-export { LwcBindingsInstrumentation, instrument } from './instrumentation';
-export { createInstrumentedAdapter } from './instrumentedAdapter';
-export { AdapterMetadata, createLDSAdapter } from './ldsAdapter';
-export { createImperativeAdapter } from './imperativeAdapter';
-export { createGraphQLImperativeAdapter } from './graphQLImperativeAdapter';
-export { createWireAdapterConstructor, createInfiniteScrollingWireAdapterConstructor, createGraphQLWireAdapterConstructor, } from './wireAdapter';
-export { DataCallback, DataCallbackTuple, ImperativeAdapter } from './imperativeAdapter';
-export { REFRESH_ADAPTER_EVENT, ADAPTER_UNFULFILLED_ERROR } from './constants';
+export { bindWireRefresh, refresh } from './bindWireRefresh';
+export { LwcBindingsInstrumentation, instrument } from './instrumentation';
+export { createInstrumentedAdapter } from './instrumentedAdapter';
+export { AdapterMetadata, createLDSAdapter } from './ldsAdapter';
+export { createImperativeAdapter } from './imperativeAdapter';
+export { createGraphQLImperativeAdapter } from './graphQLImperativeAdapter';
+export { createWireAdapterConstructor, createInfiniteScrollingWireAdapterConstructor, createGraphQLWireAdapterConstructor, } from './wireAdapter';
+export { DataCallback, DataCallbackTuple, ImperativeAdapter } from './imperativeAdapter';
+export { REFRESH_ADAPTER_EVENT, ADAPTER_UNFULFILLED_ERROR } from './constants';

package/dist/{utils → types/utils}/lanugage.d.ts

@@ -1,5 +1,5 @@
-declare const create: {
-    (o: object | null): any;
-    (o: object | null, properties: PropertyDescriptorMap & ThisType<any>): any;
-}, defineProperty: <T>(o: T, p: PropertyKey, attributes: PropertyDescriptor & ThisType<any>) => T, defineProperties: <T>(o: T, properties: PropertyDescriptorMap & ThisType<any>) => T;
-export { create as ObjectCreate, defineProperty as ObjectDefineProperty, defineProperties as ObjectDefineProperties, };
+declare const create: {
+    (o: object | null): any;
+    (o: object | null, properties: PropertyDescriptorMap & ThisType<any>): any;
+}, defineProperty: <T>(o: T, p: PropertyKey, attributes: PropertyDescriptor & ThisType<any>) => T, defineProperties: <T>(o: T, properties: PropertyDescriptorMap & ThisType<any>) => T;
+export { create as ObjectCreate, defineProperty as ObjectDefineProperty, defineProperties as ObjectDefineProperties, };

package/dist/{utils → types/utils}/snapshotType.d.ts

@@ -1,3 +1,3 @@
-import type { ErrorSnapshot, PendingSnapshot, Snapshot } from '@luvio/engine';
-export declare function isErrorSnapshot(snapshot: Snapshot<unknown, unknown>): snapshot is ErrorSnapshot;
-export declare function isPendingSnapshot<D>(snapshot: Snapshot<D, unknown>): snapshot is PendingSnapshot<D>;
+import type { ErrorSnapshot, PendingSnapshot, Snapshot } from '@luvio/engine';
+export declare function isErrorSnapshot(snapshot: Snapshot<unknown, unknown>): snapshot is ErrorSnapshot;
+export declare function isPendingSnapshot<D>(snapshot: Snapshot<D, unknown>): snapshot is PendingSnapshot<D>;

package/dist/{utils → types/utils}/utils.d.ts

@@ -1 +1 @@
-export declare function isPromise<D>(value: D | Promise<D> | null): value is Promise<D>;
+export declare function isPromise<D>(value: D | Promise<D> | null): value is Promise<D>;

package/dist/{wireAdapter.d.ts → types/wireAdapter.d.ts}

@@ -1,7 +1,7 @@
-import type { Adapter, Luvio } from '@luvio/engine';
-import type { WireAdapterConstructor } from '@lwc/engine-core';
-import type { AdapterMetadata } from './ldsAdapter';
-import type { AstResolver } from '@luvio/graphql-parser';
-export declare function createWireAdapterConstructor<C, D>(luvio: Luvio, adapter: Adapter<C, D>, metadata: AdapterMetadata): WireAdapterConstructor;
-export declare function createInfiniteScrollingWireAdapterConstructor<C, D>(luvio: Luvio, adapter: Adapter<C, D>, metadata: AdapterMetadata): WireAdapterConstructor;
-export declare function createGraphQLWireAdapterConstructor<C, D>(luvio: Luvio, adapter: Adapter<C, D>, metadata: AdapterMetadata, astResolver: AstResolver): WireAdapterConstructor;
+import type { Adapter, Luvio } from '@luvio/engine';
+import type { WireAdapterConstructor } from '@lwc/engine-core';
+import type { AdapterMetadata } from './ldsAdapter';
+import type { AstResolver } from '@luvio/graphql-parser';
+export declare function createWireAdapterConstructor<C, D>(luvio: Luvio, adapter: Adapter<C, D>, metadata: AdapterMetadata): WireAdapterConstructor;
+export declare function createInfiniteScrollingWireAdapterConstructor<C, D>(luvio: Luvio, adapter: Adapter<C, D>, metadata: AdapterMetadata): WireAdapterConstructor;
+export declare function createGraphQLWireAdapterConstructor<C, D>(luvio: Luvio, adapter: Adapter<C, D>, metadata: AdapterMetadata, astResolver: AstResolver): WireAdapterConstructor;

package/package.json

@@ -1,18 +1,18 @@
 {
     "name": "@salesforce/lds-bindings",
-    "version": "1.124.2",
+    "version": "1.124.3",
     "license": "SEE LICENSE IN LICENSE.txt",
     "description": "LDS Bindings for SFDC",
     "main": "dist/ldsBindings.js",
     "module": "dist/ldsBindings.js",
-    "types": "dist/main.d.ts",
+    "types": "dist/types/main.d.ts",
     "files": [
         "dist"
     ],
     "exports": {
         ".": {
             "import": "./dist/ldsBindings.js",
-            "types": "./dist/main.d.ts",
+            "types": "./dist/types/main.d.ts",
             "default": "./dist/ldsBindings.js"
         }
     },