@salesforce/lds-bindings 0.1.0-dev1

package/LICENSE.txt

@@ -0,0 +1,82 @@
+Terms of Use
+
+Copyright 2022 Salesforce, Inc. All rights reserved.
+
+These Terms of Use govern the download, installation, and/or use of this
+software provided by Salesforce, Inc. ("Salesforce") (the "Software"), were
+last updated on April 15, 2022, and constitute a legally binding
+agreement between you and Salesforce. If you do not agree to these Terms of
+Use, do not install or use the Software.
+
+Salesforce grants you a worldwide, non-exclusive, no-charge, royalty-free
+copyright license to reproduce, prepare derivative works of, publicly
+display, publicly perform, sublicense, and distribute the Software and
+derivative works subject to these Terms. These Terms shall be included in
+all copies or substantial portions of the Software.
+
+Subject to the limited rights expressly granted hereunder, Salesforce
+reserves all rights, title, and interest in and to all intellectual
+property subsisting in the Software. No rights are granted to you hereunder
+other than as expressly set forth herein. Users residing in countries on
+the United States Office of Foreign Assets Control sanction list, or which
+are otherwise subject to a US export embargo, may not use the Software.
+
+Implementation of the Software may require development work, for which you
+are responsible. The Software may contain bugs, errors and
+incompatibilities and is made available on an AS IS basis without support,
+updates, or service level commitments.
+
+Salesforce reserves the right at any time to modify, suspend, or
+discontinue, the Software (or any part thereof) with or without notice. You
+agree that Salesforce shall not be liable to you or to any third party for
+any modification, suspension, or discontinuance.
+
+You agree to defend Salesforce against any claim, demand, suit or
+proceeding made or brought against Salesforce by a third party arising out
+of or accruing from (a) your use of the Software, and (b) any application
+you develop with the Software that infringes any copyright, trademark,
+trade secret, trade dress, patent, or other intellectual property right of
+any person or defames any person or violates their rights of publicity or
+privacy (each a "Claim Against Salesforce"), and will indemnify Salesforce
+from any damages, attorney fees, and costs finally awarded against
+Salesforce as a result of, or for any amounts paid by Salesforce under a
+settlement approved by you in writing of, a Claim Against Salesforce,
+provided Salesforce (x) promptly gives you written notice of the Claim
+Against Salesforce, (y) gives you sole control of the defense and
+settlement of the Claim Against Salesforce (except that you may not settle
+any Claim Against Salesforce unless it unconditionally releases Salesforce
+of all liability), and (z) gives you all reasonable assistance, at your
+expense.
+
+WITHOUT LIMITING THE GENERALITY OF THE FOREGOING, THE SOFTWARE IS NOT
+SUPPORTED AND IS PROVIDED "AS IS," WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED. IN NO EVENT SHALL SALESFORCE HAVE ANY LIABILITY FOR ANY DAMAGES,
+INCLUDING, BUT NOT LIMITED TO, DIRECT, INDIRECT, SPECIAL, INCIDENTAL,
+PUNITIVE, OR CONSEQUENTIAL DAMAGES, OR DAMAGES BASED ON LOST PROFITS, DATA,
+OR USE, IN CONNECTION WITH THE SOFTWARE, HOWEVER CAUSED AND WHETHER IN
+CONTRACT, TORT, OR UNDER ANY OTHER THEORY OF LIABILITY, WHETHER OR NOT YOU
+HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+
+These Terms of Use shall be governed exclusively by the internal laws of
+the State of California, without regard to its conflicts of laws
+rules. Each party hereby consents to the exclusive jurisdiction of the
+state and federal courts located in San Francisco County, California to
+adjudicate any dispute arising out of or relating to these Terms of Use and
+the download, installation, and/or use of the Software. Except as expressly
+stated herein, these Terms of Use constitute the entire agreement between
+the parties, and supersede all prior and contemporaneous agreements,
+proposals, or representations, written or oral, concerning their subject
+matter. No modification, amendment, or waiver of any provision of these
+Terms of Use shall be effective unless it is by an update to these Terms of
+Use that Salesforce makes available, or is in writing and signed by the
+party against whom the modification, amendment, or waiver is to be
+asserted.
+
+Data Privacy: Salesforce may collect, process, and store device,
+system, and other information related to your use of the Software. This
+information includes, but is not limited to, IP address, user metrics, and
+other data ("Usage Data"). Salesforce may use Usage Data for analytics,
+product development, and marketing purposes. You acknowledge that files
+generated in conjunction with the Software may contain sensitive or
+confidential data, and you are solely responsible for anonymizing and
+protecting such data.

package/dist/ldsBindings.js

@@ -0,0 +1,1054 @@
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+/*
+ *  ATTENTION!
+ *  THIS IS A GENERATED FILE FROM https://github.com/salesforce-experience-platform-emu/lds-lightning-platform
+ *  If you would like to contribute to LDS, please follow the steps outlined in the git repo.
+ *  Any changes made to this file in p4 will be automatically overwritten.
+ *  *******************************************************************************************
+ */
+/* proxy-compat-disable */
+import { unwrap } from 'lwc';
+
+// instrumentation keys to be imported by ldsInstrumentation
+const REFRESH_ADAPTER_EVENT = 'refresh-adapter-event';
+const ADAPTER_UNFULFILLED_ERROR = 'adapter-unfulfilled-error';
+const USERLAND_PROVISION_ERROR_MESSAGE = "LWC component's @wire target property or method threw an error during value provisioning. Original error:";
+const ADAPTER_SNAPSHOT_REJECTED_MESSAGE = 'Luvio wire adapter Promise<Snapshot> rejected. Original error:';
+const 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
+const dataToTupleWeakMap = new WeakMap();
+
+var SnapshotState$1;
+(function (SnapshotState) {
+    SnapshotState["Fulfilled"] = "Fulfilled";
+    SnapshotState["Unfulfilled"] = "Unfulfilled";
+    SnapshotState["Error"] = "Error";
+    SnapshotState["Pending"] = "Pending";
+    SnapshotState["Stale"] = "Stale";
+})(SnapshotState$1 || (SnapshotState$1 = {}));
+function isErrorSnapshot$1(snapshot) {
+    return snapshot.state === SnapshotState$1.Error;
+}
+function isFulfilledSnapshot(snapshot) {
+    return snapshot.state === SnapshotState$1.Fulfilled;
+}
+function isStaleSnapshot(snapshot) {
+    return snapshot.state === SnapshotState$1.Stale;
+}
+function isUnfulfilledSnapshot(snapshot) {
+    return snapshot.state === SnapshotState$1.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$1(snapshot)) {
+        return {
+            data: undefined,
+            error: snapshot.error,
+        };
+    }
+    // fulfilled or stale
+    return {
+        data: snapshot.data,
+        error: undefined,
+    };
+}
+
+function bindWireRefresh$1(luvio) {
+    return function refresh(data) {
+        return refreshData(data, dataToTupleWeakMap, luvio);
+    };
+}
+function refreshData(data, dataToTuple, luvio) {
+    const tuple = dataToTuple.get(unwrap(data));
+    if (tuple === undefined) {
+        if (process.env.NODE_ENV !== 'production') {
+            throw new Error('Refresh failed because resolved configuration is not available.');
+        }
+        return;
+    }
+    const [adapterName, snapshot] = tuple;
+    luvio.instrument(() => {
+        return {
+            [REFRESH_ADAPTER_EVENT]: true,
+            adapterName,
+        };
+    });
+    // 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((refreshed) => {
+        if (isErrorSnapshot$1(refreshed)) {
+            throw refreshed.error;
+        }
+        if (process.env.NODE_ENV !== 'production') {
+            if (isUnfulfilledSnapshot(refreshed)) {
+                throw new Error('Refresh resulted in unfulfilled snapshot');
+            }
+        }
+        return undefined;
+    });
+}
+
+function isPromise$1(value) {
+    // check for Thenable due to test frameworks using custom Promise impls
+    return value.then !== undefined;
+}
+
+const { isArray } = Array;
+const { stringify } = JSON;
+
+/**
+ * (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 = `${messagePrefix}\n[${error.message}]`;
+        throw error;
+    }
+    throw new Error(`${messagePrefix}\n[${stringify(error)}]`);
+}
+
+class Sanitizer {
+    constructor(obj) {
+        this.obj = obj;
+        this.copy = {};
+        this.currentPath = {
+            key: '',
+            value: obj,
+            parent: null,
+            data: this.copy,
+        };
+    }
+    sanitize() {
+        const sanitizer = this;
+        stringify(this.obj, function (key, value) {
+            if (key === '') {
+                return value;
+            }
+            const 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;
+    }
+    enter(key, value) {
+        const { currentPath: parentPath } = this;
+        const data = (parentPath.data[key] = isArray(value) ? [] : {});
+        this.currentPath = {
+            key,
+            value,
+            parent: parentPath,
+            data,
+        };
+    }
+    exit(parent) {
+        while (this.currentPath.value !== parent) {
+            this.currentPath = this.currentPath.parent || this.currentPath;
+        }
+    }
+}
+/**
+ * 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();
+}
+
+class LWCLuvioWireAdapter {
+    /**
+     * Constructs a new wire adapter instance for the given adapter.
+     *
+     * @param callback callback to be invoked with new values
+     */
+    constructor(adapter, name, luvio, callback, sourceContext) {
+        // 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;
+        this.sourceContext = sourceContext;
+        // 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.
+     */
+    connect() {
+        this.connected = true;
+        this.callAdapter(this.generateAdapterRequestContext());
+    }
+    /**
+     * Called when the component associated with the wire adapter is disconnected.
+     */
+    disconnect() {
+        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
+     */
+    update(config, context) {
+        this.unsubscribe();
+        this.config = sanitize(config);
+        this.callAdapter(this.generateAdapterRequestContext(context));
+    }
+    // private and protected utility methods
+    /**
+     * Accepts a WireContext and generates corresponding AdapterRequestContext
+     */
+    generateAdapterRequestContext(_context) {
+        if (!this.sourceContext) {
+            return {};
+        }
+        return {
+            sourceContext: { ...this.sourceContext },
+        };
+    }
+    /**
+     * Calls the adapter if config has been set and the component is connected.
+     */
+    callAdapter(context) {
+        if (!this.connected || this.config === undefined) {
+            return;
+        }
+        const snapshotOrPromise = this.adapter(this.config, context);
+        this.processAdapterResponse(snapshotOrPromise);
+    }
+    processAdapterResponse(snapshotOrPromise) {
+        // insufficient config, wait for new config from component
+        if (snapshotOrPromise === null) {
+            return;
+        }
+        const configForSnapshot = this.config;
+        const emitAndSubscribe = (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: ${snapshot.missingPaths.keysAsArray()}`);
+                }
+                // Instrument as a failed request
+                this.luvio.instrument(() => {
+                    return {
+                        [ADAPTER_UNFULFILLED_ERROR]: true,
+                        adapterName: this.adapter.name,
+                        missingPaths: snapshot.missingPaths,
+                        missingLinks: snapshot.missingLinks,
+                    };
+                });
+                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$1(snapshot) ||
+                isStaleSnapshot(snapshot)) {
+                this.emit(snapshot);
+            }
+            // subscribe to the new snapshot
+            this.subscribe(snapshot);
+        };
+        // Data resolved sync
+        if (!isPromise$1(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, (error) => 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
+     */
+    emit(snapshot) {
+        const 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
+     */
+    subscribe(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).
+     */
+    unsubscribe() {
+        // clean up subscription
+        if (this.unsubscriber !== undefined) {
+            this.unsubscriber();
+            this.unsubscriber = undefined;
+        }
+    }
+}
+/**
+ * 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$1(adapter, name, luvio) {
+    const constructor = function (callback, sourceContext) {
+        const delegate = new LWCLuvioWireAdapter(adapter, name, luvio, callback, sourceContext);
+        this.connect = () => delegate.connect();
+        this.disconnect = () => delegate.disconnect();
+        this.update = (config, context) => delegate.update(config, context);
+    };
+    Object.defineProperty(constructor, 'name', { value: name });
+    return constructor;
+}
+
+/**
+ * Simple deep equality comparison for configuration objects.
+ * Handles primitives, arrays, and plain objects.
+ */
+function deepEquals(a, b) {
+    if (a === b) {
+        return true;
+    }
+    if (a === null || a === undefined || b === null || b === undefined) {
+        return a === b;
+    }
+    if (typeof a !== typeof b) {
+        return false;
+    }
+    if (typeof a !== 'object') {
+        return false;
+    }
+    if (Array.isArray(a) !== Array.isArray(b)) {
+        return false;
+    }
+    if (Array.isArray(a) && Array.isArray(b)) {
+        if (a.length !== b.length) {
+            return false;
+        }
+        for (let i = 0; i < a.length; i++) {
+            if (!deepEquals(a[i], b[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    // Handle plain objects
+    const aKeys = Object.keys(a);
+    const bKeys = Object.keys(b);
+    if (aKeys.length !== bKeys.length) {
+        return false;
+    }
+    for (const key of aKeys) {
+        if (!bKeys.includes(key)) {
+            return false;
+        }
+        if (!deepEquals(a[key], b[key])) {
+            return false;
+        }
+    }
+    return true;
+}
+class LWCInfinteScrollingLuvioWireAdapter extends LWCLuvioWireAdapter {
+    constructor(adapter, name, luvio, callback, sourceContext, paginationConfigParamNames) {
+        super(adapter, name, luvio, callback, sourceContext);
+        this.paginationConfigParamNames = paginationConfigParamNames;
+    }
+    /**
+     * Called when the component associated with the wire adapter is connected.
+     */
+    connect() {
+        this.connectTimestamp = Date.now();
+        super.connect();
+    }
+    /**
+     * Called when the component associated with the wire adapter is disconnected.
+     */
+    disconnect() {
+        this.connectTimestamp = undefined;
+        super.disconnect();
+    }
+    /**
+     * 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
+     */
+    update(config, context) {
+        if (this.connectTimestamp) {
+            // compare the incoming config with the current config.
+            // if any non-pagination config params have changed, we need to reset the connectTimestamp
+            const currentConfig = this.config;
+            // Check if any non-pagination parameters have changed
+            const hasNonPaginationParamChanged = Object.keys(config).some((paramName) => {
+                var _a;
+                // If this is not a pagination param and its value has changed
+                return (!((_a = this.paginationConfigParamNames) === null || _a === void 0 ? void 0 : _a.includes(paramName)) &&
+                    !deepEquals(config[paramName], currentConfig === null || currentConfig === void 0 ? void 0 : currentConfig[paramName]));
+            });
+            if (hasNonPaginationParamChanged) {
+                this.connectTimestamp = Date.now();
+            }
+            const adapterRequestContext = this.generateAdapterRequestContext(context);
+            super.unsubscribe();
+            this.config = sanitize(config);
+            // this.callAdapterWithContext(mergedContext);
+            super.callAdapter(adapterRequestContext);
+        }
+        else {
+            super.update(config, context);
+        }
+    }
+    generateAdapterRequestContext(context) {
+        const baseContext = super.generateAdapterRequestContext(context);
+        // this code-path is only called when the wire adapter is connected
+        // and the connectTimestamp is set
+        return {
+            ...baseContext,
+            cachePolicy: {
+                type: 'valid-at',
+                timestamp: this.connectTimestamp,
+            },
+        };
+    }
+    subscribe(snapshot) {
+        var _a;
+        super.subscribe(snapshot);
+        // if the snapshot is refreshed we should stop using data from before the refresh
+        if (this.connected && ((_a = snapshot.refresh) === null || _a === void 0 ? void 0 : _a.resolve)) {
+            const originalResolve = snapshot.refresh.resolve;
+            snapshot.refresh.resolve = (config) => {
+                this.connectTimestamp = Date.now();
+                return originalResolve(config);
+            };
+        }
+    }
+}
+function createInfiniteScrollingWireAdapterConstructor$1(adapter, name, luvio, paginationConfigParamNames) {
+    const constructor = function (callback, sourceContext) {
+        const delegate = new LWCInfinteScrollingLuvioWireAdapter(adapter, name, luvio, callback, sourceContext, paginationConfigParamNames);
+        this.connect = () => delegate.connect();
+        this.disconnect = () => delegate.disconnect();
+        this.update = (config, context) => delegate.update(config, context);
+    };
+    Object.defineProperty(constructor, 'name', { value: name });
+    return constructor;
+}
+
+function snapshotToPayload(snapshot) {
+    const 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;
+}
+class LWCGraphQLLuvioWireAdapter extends LWCLuvioWireAdapter {
+    constructor(adapter, name, luvio, astResolver, callback, sourceContext) {
+        super(adapter, name, luvio, callback, sourceContext);
+        this.astResolver = astResolver;
+    }
+    update(config, context) {
+        this.unsubscribe();
+        if (config.batchQuery) {
+            this.config = {
+                batchQuery: config.batchQuery.map((individualConfig) => safeSanitizeGraphQLConfigObject(individualConfig)),
+            };
+        }
+        else {
+            this.config = safeSanitizeGraphQLConfigObject(config);
+        }
+        this.callAdapter(super.generateAdapterRequestContext(context));
+    }
+    /**
+     * Emits new values to the callback.
+     *
+     * @param snapshot Snapshot to be emitted, if omitted then undefineds will be emitted
+     */
+    emit(snapshot) {
+        const 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
+     */
+    callAdapter(context) {
+        if (!this.connected || this.config === undefined) {
+            return;
+        }
+        const config = this.config;
+        if ('batchQuery' in config) {
+            const batchConfig = {
+                batchQuery: config.batchQuery.map((individualConfig) => this.resolveQueryAst(individualConfig)),
+            };
+            // If any of the configurations are invalid, we bail out of calling the adapter.
+            if (batchConfig.batchQuery.some((val) => val === undefined)) {
+                return;
+            }
+            const snapshotOrPromise = this.adapter(batchConfig, context);
+            this.processAdapterResponse(snapshotOrPromise);
+        }
+        else if ('query' in config) {
+            const singleConfig = this.resolveQueryAst(config);
+            if (singleConfig !== undefined) {
+                const snapshotOrPromise = this.adapter(singleConfig, context);
+                this.processAdapterResponse(snapshotOrPromise);
+            }
+        }
+    }
+    resolveQueryAst(config) {
+        if (config.query === null) {
+            return;
+        }
+        const 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;
+        }
+        const resolvedAdapterConfig = {
+            ...config,
+            query: ast,
+        };
+        return resolvedAdapterConfig;
+    }
+}
+function extractSnapshotData(snapshot) {
+    if ('data' in snapshot && snapshot.data !== undefined) {
+        const isSingleGraphQLData = 'data' in snapshot.data && snapshot.data.data !== undefined;
+        const 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$1(adapter, name, luvio, astResolver) {
+    const constructor = function (callback, sourceContext) {
+        const delegate = new LWCGraphQLLuvioWireAdapter(adapter, name, luvio, astResolver, callback, sourceContext);
+        this.connect = () => delegate.connect();
+        this.disconnect = () => delegate.disconnect();
+        this.update = (config, context) => 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 {
+        ...sanitize(config),
+        query: config.query,
+    };
+}
+
+// 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);
+    };
+}
+
+function createInstrumentedAdapter(adapter, metadata) {
+    return instrumentation.instrumentAdapter(adapter, metadata);
+}
+
+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;
+}
+
+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));
+        })
+            .finally(() => {
+            luvio.storeCleanup();
+        });
+    };
+    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;
+}
+/**
+ * The graphql batch snapshot should be treated the same as a regular imperative adapter snapshot.
+ * @param snapshot - The snapshot to convert to a tuple
+ * @returns The tuple representation of the snapshot
+ */
+function batchSnapshotToTuple(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() {
+    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;
+        let isBatch = false;
+        if ('batchQuery' in config) {
+            isBatch = true;
+            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(isBatch
+                ? batchSnapshotToTuple(snapshotOrPromise)
+                : snapshotToTuple(snapshotOrPromise));
+            return;
+        }
+        snapshotOrPromise
+            .then((snapshot) => {
+            if (snapshot === null) {
+                callback(createInvalidConfigError());
+                return;
+            }
+            callback(isBatch ? batchSnapshotToTuple(snapshot) : snapshotToTuple(snapshot));
+        })
+            .finally(() => {
+            luvio.storeCleanup();
+        });
+    };
+    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;
+        let isBatch = false;
+        if ('batchQuery' in config) {
+            isBatch = true;
+            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(isBatch
+                        ? batchSnapshotToTuple(snapshotFromRebuild)
+                        : 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(isBatch
+                    ? batchSnapshotToTuple(snapshotOrPromise)
+                    : 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(isBatch ? batchSnapshotToTuple(snapshot) : 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, paginationConfigParamNames) {
+    const { apiFamily, name } = metadata;
+    return createInfiniteScrollingWireAdapterConstructor$1(adapter, `${apiFamily}.${name}`, luvio, paginationConfigParamNames);
+}
+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: 0.1.0-dev1-54c03dd38c

package/dist/types/bindWireRefresh.d.ts

@@ -0,0 +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;

package/dist/types/constants.d.ts

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

package/dist/types/graphQLImperativeAdapter.d.ts

@@ -0,0 +1,40 @@
+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[];
+}
+interface BatchDataResponse {
+    data: any;
+    error?: undefined;
+}
+interface BatchErrorResponse {
+    data: undefined;
+    error: LuvioErrorResponse;
+}
+type DataCallbackTuple = DataResponse | ErrorResponse | BatchDataResponse | BatchErrorResponse;
+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;
+export 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/types/imperativeAdapter.d.ts

@@ -0,0 +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 {};

package/dist/types/instrumentation.d.ts

@@ -0,0 +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;

package/dist/types/instrumentedAdapter.d.ts

@@ -0,0 +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>;

package/dist/types/ldsAdapter.d.ts

@@ -0,0 +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;

package/dist/types/main.d.ts

@@ -0,0 +1,10 @@
+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 { ImperativeAdapter as GraphQLImperativeAdapter } from './graphQLImperativeAdapter';
+export { REFRESH_ADAPTER_EVENT, ADAPTER_UNFULFILLED_ERROR } from './constants';

package/dist/types/utils/lanugage.d.ts

@@ -0,0 +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, };

package/dist/types/utils/snapshotType.d.ts

@@ -0,0 +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>;

package/dist/types/utils/utils.d.ts

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

package/dist/types/wireAdapter.d.ts

@@ -0,0 +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, paginationConfigParamNames?: string[]): WireAdapterConstructor;
+export declare function createGraphQLWireAdapterConstructor<C, D>(luvio: Luvio, adapter: Adapter<C, D>, metadata: AdapterMetadata, astResolver: AstResolver): WireAdapterConstructor;

package/package.json

@@ -0,0 +1,42 @@
+{
+    "name": "@salesforce/lds-bindings",
+    "version": "0.1.0-dev1",
+    "license": "SEE LICENSE IN LICENSE.txt",
+    "description": "LDS Bindings for SFDC",
+    "main": "dist/ldsBindings.js",
+    "module": "dist/ldsBindings.js",
+    "types": "dist/types/main.d.ts",
+    "files": [
+        "dist"
+    ],
+    "exports": {
+        ".": {
+            "types": "./dist/types/main.d.ts",
+            "import": "./dist/ldsBindings.js",
+            "default": "./dist/ldsBindings.js"
+        }
+    },
+    "sfdc": {
+        "path": "forcelds/ldsBindings/",
+        "overrides": {
+            "artifactDirectory": "dist"
+        }
+    },
+    "scripts": {
+        "prepare": "yarn build",
+        "build": "rollup --bundleConfigAsCjs --config rollup.config.js",
+        "clean": "rm -rf dist",
+        "test:unit": "jest",
+        "test:unit:debug": "node --inspect-brk ../../node_modules/.bin/jest --runInBand",
+        "release:corejar": "yarn build && ../core-build/scripts/core.js --name=lds-bindings"
+    },
+    "dependencies": {
+        "@salesforce/lds-graphql-parser": "^0.1.0-dev1"
+    },
+    "devDependencies": {
+        "@lwc/engine-core": "2.42.0"
+    },
+    "volta": {
+        "extends": "../../package.json"
+    }
+}