@salesforce/lds-network-adapter 1.124.2 → 1.124.3

package/dist/ldsNetwork.js

@@ -6,467 +6,467 @@
 
 import { HttpStatusCode } from '@luvio/engine';
 
-const { parse, stringify } = JSON;
-const { join, push, unshift } = Array.prototype;
-const { isArray } = Array;
+const { parse, stringify } = JSON;
+const { join, push, unshift } = Array.prototype;
+const { isArray } = Array;
 const { entries, keys } = Object;
 
 const UI_API_BASE_URI = '/services/data/v58.0/ui-api';
 
-let instrumentation = {
-    aggregateUiChunkCount: (_cb) => { },
-    aggregateUiConnectError: () => { },
-    duplicateRequest: (_cb) => { },
-    getRecordAggregateInvoke: () => { },
-    getRecordAggregateResolve: (_cb) => { },
-    getRecordAggregateReject: (_cb) => { },
-    getRecordAggregateRetry: () => { },
-    getRecordNormalInvoke: () => { },
-    networkRateLimitExceeded: () => { },
-};
-function instrument(newInstrumentation) {
-    instrumentation = Object.assign(instrumentation, newInstrumentation);
+let instrumentation = {
+    aggregateUiChunkCount: (_cb) => { },
+    aggregateUiConnectError: () => { },
+    duplicateRequest: (_cb) => { },
+    getRecordAggregateInvoke: () => { },
+    getRecordAggregateResolve: (_cb) => { },
+    getRecordAggregateReject: (_cb) => { },
+    getRecordAggregateRetry: () => { },
+    getRecordNormalInvoke: () => { },
+    networkRateLimitExceeded: () => { },
+};
+function instrument(newInstrumentation) {
+    instrumentation = Object.assign(instrumentation, newInstrumentation);
 }
 
-const LDS_RECORDS_AGGREGATE_UI = 'LDS_Records_AggregateUi';
-// Boundary which represents the limit that we start chunking at,
-// determined by comma separated string length of fields
-const MAX_STRING_LENGTH_PER_CHUNK = 10000;
-// UIAPI limit
-const MAX_AGGREGATE_UI_CHUNK_LIMIT = 50;
-function createOkResponse(body) {
-    return {
-        status: HttpStatusCode.Ok,
-        body,
-        statusText: 'ok',
-        headers: {},
-        ok: true,
-    };
-}
-function getErrorResponseText(status) {
-    switch (status) {
-        case HttpStatusCode.Ok:
-            return 'OK';
-        case HttpStatusCode.NotModified:
-            return 'Not Modified';
-        case HttpStatusCode.NotFound:
-            return 'Not Found';
-        case HttpStatusCode.BadRequest:
-            return 'Bad Request';
-        case HttpStatusCode.ServerError:
-            return 'Server Error';
-        default:
-            return `Unexpected HTTP Status Code: ${status}`;
-    }
-}
-function createErrorResponse(status, body) {
-    return {
-        status,
-        body,
-        statusText: getErrorResponseText(status),
-        headers: {},
-        ok: false,
-    };
-}
-function isSpanningRecord(fieldValue) {
-    return fieldValue !== null && typeof fieldValue === 'object';
-}
-function mergeRecordFields(first, second) {
-    const { fields: targetFields } = first;
-    const { fields: sourceFields } = second;
-    const fieldNames = keys(sourceFields);
-    for (let i = 0, len = fieldNames.length; i < len; i += 1) {
-        const fieldName = fieldNames[i];
-        const sourceField = sourceFields[fieldName];
-        const targetField = targetFields[fieldName];
-        if (isSpanningRecord(sourceField.value)) {
-            if (targetField === undefined) {
-                targetFields[fieldName] = sourceFields[fieldName];
-                continue;
-            }
-            mergeRecordFields(targetField.value, sourceField.value);
-            continue;
-        }
-        targetFields[fieldName] = sourceFields[fieldName];
-    }
-    return first;
-}
-/** Invoke executeAggregateUi Aura controller.  This is only to be used with large getRecord requests that
- *  would otherwise cause a query length exception.
- */
-function dispatchSplitRecordAggregateUiAction(recordId, networkAdapter, resourceRequest, resourceRequestContext) {
-    instrumentation.getRecordAggregateInvoke();
-    return networkAdapter(resourceRequest, resourceRequestContext).then((resp) => {
-        const { body } = resp;
-        // This response body could be an executeAggregateUi, which we don't natively support.
-        // Massage it into looking like a getRecord response.
-        if (body === null ||
-            body === undefined ||
-            body.compositeResponse === undefined ||
-            body.compositeResponse.length === 0) {
-            // We shouldn't even get into this state - a 200 with no body?
-            throw createErrorResponse(HttpStatusCode.ServerError, {
-                error: 'No response body in executeAggregateUi found',
-            });
-        }
-        const merged = body.compositeResponse.reduce((seed, response) => {
-            if (response.httpStatusCode !== HttpStatusCode.Ok) {
-                instrumentation.getRecordAggregateReject(() => recordId);
-                throw createErrorResponse(HttpStatusCode.ServerError, {
-                    error: response.message,
-                });
-            }
-            if (seed === null) {
-                return response.body;
-            }
-            return mergeRecordFields(seed, response.body);
-        }, null);
-        instrumentation.getRecordAggregateResolve(() => {
-            return {
-                recordId,
-                apiName: merged.apiName,
-            };
-        });
-        return createOkResponse(merged);
-    }, (err) => {
-        instrumentation.getRecordAggregateReject(() => recordId);
-        // rethrow error
-        throw err;
-    });
-}
-function shouldUseAggregateUiForGetRecord(fieldsArray, optionalFieldsArray) {
-    return fieldsArray.length + optionalFieldsArray.length >= MAX_STRING_LENGTH_PER_CHUNK;
-}
-function buildAggregateUiUrl(params, resourceRequest) {
-    const { fields, optionalFields } = params;
-    const queryString = [];
-    if (fields !== undefined && fields.length > 0) {
-        const fieldString = join.call(fields, ',');
-        push.call(queryString, `fields=${encodeURIComponent(fieldString)}`);
-    }
-    if (optionalFields !== undefined && optionalFields.length > 0) {
-        const optionalFieldString = join.call(optionalFields, ',');
-        push.call(queryString, `optionalFields=${encodeURIComponent(optionalFieldString)}`);
-    }
-    return `${resourceRequest.baseUri}${resourceRequest.basePath}?${join.call(queryString, '&')}`;
-}
-function buildGetRecordByFieldsCompositeRequest(resourceRequest, recordsCompositeRequest) {
-    const { fieldsArray, optionalFieldsArray, fieldsLength, optionalFieldsLength } = recordsCompositeRequest;
-    // Formula:  # of fields per chunk = floor(avg field length / max length per chunk)
-    const averageFieldStringLength = Math.floor((fieldsLength + optionalFieldsLength) / (fieldsArray.length + optionalFieldsArray.length));
-    const fieldsPerChunk = Math.floor(MAX_STRING_LENGTH_PER_CHUNK / averageFieldStringLength);
-    const optionalFieldsChunks = [];
-    // Do the same for optional tracked fields
-    for (let i = 0, j = optionalFieldsArray.length; i < j; i += fieldsPerChunk) {
-        const newChunk = optionalFieldsArray.slice(i, i + fieldsPerChunk);
-        push.call(optionalFieldsChunks, newChunk);
-    }
-    const compositeRequest = [];
-    // Add fields as one chunk at the beginning of the compositeRequest
-    if (fieldsArray.length > 0) {
-        const url = buildAggregateUiUrl({
-            fields: fieldsArray,
-        }, resourceRequest);
-        push.call(compositeRequest, {
-            url,
-            referenceId: `${LDS_RECORDS_AGGREGATE_UI}_fields`,
-        });
-    }
-    // Make sure we don't exceed the max subquery chunk limit for aggUi by capping the amount
-    // of optionalFields subqueries at MAX_AGGREGATE_UI_CHUNK_LIMIT - 1 (first chunk is for fields)
-    const maxNumberOfAllowableOptionalFieldsChunks = MAX_AGGREGATE_UI_CHUNK_LIMIT - 1;
-    const optionalFieldsChunksLength = Math.min(optionalFieldsChunks.length, maxNumberOfAllowableOptionalFieldsChunks);
-    for (let i = 0; i < optionalFieldsChunksLength; i += 1) {
-        const fieldChunk = optionalFieldsChunks[i];
-        const url = buildAggregateUiUrl({
-            optionalFields: fieldChunk,
-        }, resourceRequest);
-        push.call(compositeRequest, {
-            url,
-            referenceId: `${LDS_RECORDS_AGGREGATE_UI}_optionalFields_${i}`,
-        });
-    }
-    return compositeRequest;
+const LDS_RECORDS_AGGREGATE_UI = 'LDS_Records_AggregateUi';
+// Boundary which represents the limit that we start chunking at,
+// determined by comma separated string length of fields
+const MAX_STRING_LENGTH_PER_CHUNK = 10000;
+// UIAPI limit
+const MAX_AGGREGATE_UI_CHUNK_LIMIT = 50;
+function createOkResponse(body) {
+    return {
+        status: HttpStatusCode.Ok,
+        body,
+        statusText: 'ok',
+        headers: {},
+        ok: true,
+    };
+}
+function getErrorResponseText(status) {
+    switch (status) {
+        case HttpStatusCode.Ok:
+            return 'OK';
+        case HttpStatusCode.NotModified:
+            return 'Not Modified';
+        case HttpStatusCode.NotFound:
+            return 'Not Found';
+        case HttpStatusCode.BadRequest:
+            return 'Bad Request';
+        case HttpStatusCode.ServerError:
+            return 'Server Error';
+        default:
+            return `Unexpected HTTP Status Code: ${status}`;
+    }
+}
+function createErrorResponse(status, body) {
+    return {
+        status,
+        body,
+        statusText: getErrorResponseText(status),
+        headers: {},
+        ok: false,
+    };
+}
+function isSpanningRecord(fieldValue) {
+    return fieldValue !== null && typeof fieldValue === 'object';
+}
+function mergeRecordFields(first, second) {
+    const { fields: targetFields } = first;
+    const { fields: sourceFields } = second;
+    const fieldNames = keys(sourceFields);
+    for (let i = 0, len = fieldNames.length; i < len; i += 1) {
+        const fieldName = fieldNames[i];
+        const sourceField = sourceFields[fieldName];
+        const targetField = targetFields[fieldName];
+        if (isSpanningRecord(sourceField.value)) {
+            if (targetField === undefined) {
+                targetFields[fieldName] = sourceFields[fieldName];
+                continue;
+            }
+            mergeRecordFields(targetField.value, sourceField.value);
+            continue;
+        }
+        targetFields[fieldName] = sourceFields[fieldName];
+    }
+    return first;
+}
+/** Invoke executeAggregateUi Aura controller.  This is only to be used with large getRecord requests that
+ *  would otherwise cause a query length exception.
+ */
+function dispatchSplitRecordAggregateUiAction(recordId, networkAdapter, resourceRequest, resourceRequestContext) {
+    instrumentation.getRecordAggregateInvoke();
+    return networkAdapter(resourceRequest, resourceRequestContext).then((resp) => {
+        const { body } = resp;
+        // This response body could be an executeAggregateUi, which we don't natively support.
+        // Massage it into looking like a getRecord response.
+        if (body === null ||
+            body === undefined ||
+            body.compositeResponse === undefined ||
+            body.compositeResponse.length === 0) {
+            // We shouldn't even get into this state - a 200 with no body?
+            throw createErrorResponse(HttpStatusCode.ServerError, {
+                error: 'No response body in executeAggregateUi found',
+            });
+        }
+        const merged = body.compositeResponse.reduce((seed, response) => {
+            if (response.httpStatusCode !== HttpStatusCode.Ok) {
+                instrumentation.getRecordAggregateReject(() => recordId);
+                throw createErrorResponse(HttpStatusCode.ServerError, {
+                    error: response.message,
+                });
+            }
+            if (seed === null) {
+                return response.body;
+            }
+            return mergeRecordFields(seed, response.body);
+        }, null);
+        instrumentation.getRecordAggregateResolve(() => {
+            return {
+                recordId,
+                apiName: merged.apiName,
+            };
+        });
+        return createOkResponse(merged);
+    }, (err) => {
+        instrumentation.getRecordAggregateReject(() => recordId);
+        // rethrow error
+        throw err;
+    });
+}
+function shouldUseAggregateUiForGetRecord(fieldsArray, optionalFieldsArray) {
+    return fieldsArray.length + optionalFieldsArray.length >= MAX_STRING_LENGTH_PER_CHUNK;
+}
+function buildAggregateUiUrl(params, resourceRequest) {
+    const { fields, optionalFields } = params;
+    const queryString = [];
+    if (fields !== undefined && fields.length > 0) {
+        const fieldString = join.call(fields, ',');
+        push.call(queryString, `fields=${encodeURIComponent(fieldString)}`);
+    }
+    if (optionalFields !== undefined && optionalFields.length > 0) {
+        const optionalFieldString = join.call(optionalFields, ',');
+        push.call(queryString, `optionalFields=${encodeURIComponent(optionalFieldString)}`);
+    }
+    return `${resourceRequest.baseUri}${resourceRequest.basePath}?${join.call(queryString, '&')}`;
+}
+function buildGetRecordByFieldsCompositeRequest(resourceRequest, recordsCompositeRequest) {
+    const { fieldsArray, optionalFieldsArray, fieldsLength, optionalFieldsLength } = recordsCompositeRequest;
+    // Formula:  # of fields per chunk = floor(avg field length / max length per chunk)
+    const averageFieldStringLength = Math.floor((fieldsLength + optionalFieldsLength) / (fieldsArray.length + optionalFieldsArray.length));
+    const fieldsPerChunk = Math.floor(MAX_STRING_LENGTH_PER_CHUNK / averageFieldStringLength);
+    const optionalFieldsChunks = [];
+    // Do the same for optional tracked fields
+    for (let i = 0, j = optionalFieldsArray.length; i < j; i += fieldsPerChunk) {
+        const newChunk = optionalFieldsArray.slice(i, i + fieldsPerChunk);
+        push.call(optionalFieldsChunks, newChunk);
+    }
+    const compositeRequest = [];
+    // Add fields as one chunk at the beginning of the compositeRequest
+    if (fieldsArray.length > 0) {
+        const url = buildAggregateUiUrl({
+            fields: fieldsArray,
+        }, resourceRequest);
+        push.call(compositeRequest, {
+            url,
+            referenceId: `${LDS_RECORDS_AGGREGATE_UI}_fields`,
+        });
+    }
+    // Make sure we don't exceed the max subquery chunk limit for aggUi by capping the amount
+    // of optionalFields subqueries at MAX_AGGREGATE_UI_CHUNK_LIMIT - 1 (first chunk is for fields)
+    const maxNumberOfAllowableOptionalFieldsChunks = MAX_AGGREGATE_UI_CHUNK_LIMIT - 1;
+    const optionalFieldsChunksLength = Math.min(optionalFieldsChunks.length, maxNumberOfAllowableOptionalFieldsChunks);
+    for (let i = 0; i < optionalFieldsChunksLength; i += 1) {
+        const fieldChunk = optionalFieldsChunks[i];
+        const url = buildAggregateUiUrl({
+            optionalFields: fieldChunk,
+        }, resourceRequest);
+        push.call(compositeRequest, {
+            url,
+            referenceId: `${LDS_RECORDS_AGGREGATE_UI}_optionalFields_${i}`,
+        });
+    }
+    return compositeRequest;
 }
 
-const UIAPI_RECORDS_PATH = `${UI_API_BASE_URI}/records`;
-const UIAPI_RECORDS_BATCH_PATH = `${UI_API_BASE_URI}/records/batch/`;
-const QUERY_TOO_COMPLICATED_ERROR_CODE = 'QUERY_TOO_COMPLICATED';
-function fetchResponseIsQueryTooComplicated(error) {
-    const { body } = error;
-    if (error.status === HttpStatusCode.BadRequest && body !== undefined) {
-        return (body.statusCode === HttpStatusCode.BadRequest &&
-            body.errorCode === QUERY_TOO_COMPLICATED_ERROR_CODE);
-    }
-    return false;
-}
-/*
- * Takes a ResourceRequest, builds the aggregateUi payload, and dispatches via aggregateUi action
- */
-function buildAndDispatchGetRecordAggregateUi(recordId, req, params) {
-    const { networkAdapter, resourceRequest, resourceRequestContext } = req;
-    const compositeRequest = buildGetRecordByFieldsCompositeRequest(resourceRequest, params);
-    // W-12245125: Emit chunk size metrics
-    instrumentation.aggregateUiChunkCount(() => compositeRequest.length);
-    const aggregateUiParams = {
-        compositeRequest,
-    };
-    const aggregateUiResourceRequest = {
-        baseUri: UI_API_BASE_URI,
-        basePath: '/aggregate-ui',
-        method: 'post',
-        priority: resourceRequest.priority,
-        urlParams: {},
-        body: aggregateUiParams,
-        queryParams: {},
-        headers: {},
-    };
-    return dispatchSplitRecordAggregateUiAction(recordId, networkAdapter, aggregateUiResourceRequest, resourceRequestContext);
-}
-const getRecordDispatcher = (req) => {
-    const { resourceRequest, networkAdapter, resourceRequestContext } = req;
-    const { queryParams, urlParams } = resourceRequest;
-    const { fields, optionalFields } = queryParams;
-    if (process.env.NODE_ENV !== 'production') {
-        if (typeof urlParams.recordId !== 'string') {
-            throw new Error(`Invalid recordId: expected string, recieved "${typeof urlParams.recordId}"`);
-        }
-    }
-    const recordId = urlParams.recordId;
-    const fieldsArray = fields !== undefined && isArray(fields) ? fields : [];
-    const optionalFieldsArray = optionalFields !== undefined && Array.isArray(optionalFields)
-        ? optionalFields
-        : [];
-    const fieldsString = fieldsArray.join(',');
-    const optionalFieldsString = optionalFieldsArray.join(',');
-    // Don't submit a megarequest to UIAPI due to SOQL limit reasons.
-    // Split and aggregate if needed
-    const useAggregateUi = shouldUseAggregateUiForGetRecord(fieldsString, optionalFieldsString);
-    if (useAggregateUi) {
-        return buildAndDispatchGetRecordAggregateUi(recordId, {
-            networkAdapter,
-            resourceRequest,
-            resourceRequestContext,
-        }, {
-            fieldsArray,
-            optionalFieldsArray,
-            fieldsLength: fieldsString.length,
-            optionalFieldsLength: optionalFieldsString.length,
-        });
-    }
-    return defaultDispatcher(req).catch((err) => {
-        if (fetchResponseIsQueryTooComplicated(err)) {
-            // Retry with aggregateUi to see if we can avoid Query Too Complicated
-            return buildAndDispatchGetRecordAggregateUi(recordId, {
-                networkAdapter,
-                resourceRequest,
-                resourceRequestContext,
-            }, {
-                fieldsArray,
-                optionalFieldsArray,
-                fieldsLength: fieldsString.length,
-                optionalFieldsLength: optionalFieldsString.length,
-            });
-        }
-        else {
-            throw err;
-        }
-    });
-};
-function matchRecordsHandlers(path, resourceRequest) {
-    const method = resourceRequest.method.toLowerCase();
-    if (method === 'get' &&
-        path.startsWith(UIAPI_RECORDS_PATH) &&
-        path.startsWith(UIAPI_RECORDS_BATCH_PATH) === false) {
-        return getRecordDispatcher;
-    }
-    return null;
+const UIAPI_RECORDS_PATH = `${UI_API_BASE_URI}/records`;
+const UIAPI_RECORDS_BATCH_PATH = `${UI_API_BASE_URI}/records/batch/`;
+const QUERY_TOO_COMPLICATED_ERROR_CODE = 'QUERY_TOO_COMPLICATED';
+function fetchResponseIsQueryTooComplicated(error) {
+    const { body } = error;
+    if (error.status === HttpStatusCode.BadRequest && body !== undefined) {
+        return (body.statusCode === HttpStatusCode.BadRequest &&
+            body.errorCode === QUERY_TOO_COMPLICATED_ERROR_CODE);
+    }
+    return false;
+}
+/*
+ * Takes a ResourceRequest, builds the aggregateUi payload, and dispatches via aggregateUi action
+ */
+function buildAndDispatchGetRecordAggregateUi(recordId, req, params) {
+    const { networkAdapter, resourceRequest, resourceRequestContext } = req;
+    const compositeRequest = buildGetRecordByFieldsCompositeRequest(resourceRequest, params);
+    // W-12245125: Emit chunk size metrics
+    instrumentation.aggregateUiChunkCount(() => compositeRequest.length);
+    const aggregateUiParams = {
+        compositeRequest,
+    };
+    const aggregateUiResourceRequest = {
+        baseUri: UI_API_BASE_URI,
+        basePath: '/aggregate-ui',
+        method: 'post',
+        priority: resourceRequest.priority,
+        urlParams: {},
+        body: aggregateUiParams,
+        queryParams: {},
+        headers: {},
+    };
+    return dispatchSplitRecordAggregateUiAction(recordId, networkAdapter, aggregateUiResourceRequest, resourceRequestContext);
+}
+const getRecordDispatcher = (req) => {
+    const { resourceRequest, networkAdapter, resourceRequestContext } = req;
+    const { queryParams, urlParams } = resourceRequest;
+    const { fields, optionalFields } = queryParams;
+    if (process.env.NODE_ENV !== 'production') {
+        if (typeof urlParams.recordId !== 'string') {
+            throw new Error(`Invalid recordId: expected string, recieved "${typeof urlParams.recordId}"`);
+        }
+    }
+    const recordId = urlParams.recordId;
+    const fieldsArray = fields !== undefined && isArray(fields) ? fields : [];
+    const optionalFieldsArray = optionalFields !== undefined && Array.isArray(optionalFields)
+        ? optionalFields
+        : [];
+    const fieldsString = fieldsArray.join(',');
+    const optionalFieldsString = optionalFieldsArray.join(',');
+    // Don't submit a megarequest to UIAPI due to SOQL limit reasons.
+    // Split and aggregate if needed
+    const useAggregateUi = shouldUseAggregateUiForGetRecord(fieldsString, optionalFieldsString);
+    if (useAggregateUi) {
+        return buildAndDispatchGetRecordAggregateUi(recordId, {
+            networkAdapter,
+            resourceRequest,
+            resourceRequestContext,
+        }, {
+            fieldsArray,
+            optionalFieldsArray,
+            fieldsLength: fieldsString.length,
+            optionalFieldsLength: optionalFieldsString.length,
+        });
+    }
+    return defaultDispatcher(req).catch((err) => {
+        if (fetchResponseIsQueryTooComplicated(err)) {
+            // Retry with aggregateUi to see if we can avoid Query Too Complicated
+            return buildAndDispatchGetRecordAggregateUi(recordId, {
+                networkAdapter,
+                resourceRequest,
+                resourceRequestContext,
+            }, {
+                fieldsArray,
+                optionalFieldsArray,
+                fieldsLength: fieldsString.length,
+                optionalFieldsLength: optionalFieldsString.length,
+            });
+        }
+        else {
+            throw err;
+        }
+    });
+};
+function matchRecordsHandlers(path, resourceRequest) {
+    const method = resourceRequest.method.toLowerCase();
+    if (method === 'get' &&
+        path.startsWith(UIAPI_RECORDS_PATH) &&
+        path.startsWith(UIAPI_RECORDS_BATCH_PATH) === false) {
+        return getRecordDispatcher;
+    }
+    return null;
 }
 
-const defaultDispatcher = (req) => {
-    const { networkAdapter, resourceRequest, resourceRequestContext } = req;
-    return networkAdapter(resourceRequest, resourceRequestContext);
-};
-function getDispatcher(resourceRequest) {
-    const { basePath, baseUri } = resourceRequest;
-    const path = `${baseUri}${basePath}`;
-    const recordsMatch = matchRecordsHandlers(path, resourceRequest);
-    if (recordsMatch !== null) {
-        return recordsMatch;
-    }
-    return defaultDispatcher;
+const defaultDispatcher = (req) => {
+    const { networkAdapter, resourceRequest, resourceRequestContext } = req;
+    return networkAdapter(resourceRequest, resourceRequestContext);
+};
+function getDispatcher(resourceRequest) {
+    const { basePath, baseUri } = resourceRequest;
+    const path = `${baseUri}${basePath}`;
+    const recordsMatch = matchRecordsHandlers(path, resourceRequest);
+    if (recordsMatch !== null) {
+        return recordsMatch;
+    }
+    return defaultDispatcher;
 }
 
-const inflightRequests = Object.create(null);
-const TRANSACTION_KEY_SEP = '::';
-const EMPTY_STRING = '';
-function isResourceRequestDedupable(resourceRequest) {
-    const resourceRequestContext = resourceRequest.resourceRequestContext;
-    return (resourceRequest.resourceRequest.method.toLowerCase() === 'get' ||
-        (resourceRequestContext && resourceRequestContext.luvioRequestMethod === 'get'));
-}
-function getTransactionKey(req) {
-    const { resourceRequest } = req;
-    const { baseUri, basePath, queryParams, headers } = resourceRequest;
-    const path = `${baseUri}${basePath}`;
-    const queryParamsString = queryParams ? stringify(queryParams) : EMPTY_STRING;
-    const headersString = stringify(headers);
-    const bodyString = resourceRequest.body && isResourceRequestDedupable(req)
-        ? stringify(resourceRequest.body)
-        : EMPTY_STRING;
-    return `${path}${TRANSACTION_KEY_SEP}${headersString}${TRANSACTION_KEY_SEP}${queryParamsString}${bodyString}`;
-}
-function getFulfillingRequest(inflightRequests, resourceRequest) {
-    const { fulfill } = resourceRequest;
-    if (fulfill === undefined) {
-        return null;
-    }
-    const handlersMap = entries(inflightRequests);
-    for (let i = 0, len = handlersMap.length; i < len; i += 1) {
-        const [transactionKey, handlers] = handlersMap[i];
-        // check fulfillment against only the first handler ([0]) because it's equal or
-        // fulfills all subsequent handlers in the array
-        const existing = handlers[0].resourceRequest;
-        if (fulfill(existing, resourceRequest) === true) {
-            return transactionKey;
-        }
-    }
-    return null;
-}
-/**
-  Dedupes network requests being made to Salesforce APIs
-  This function is only designed to dedupe GET requests.
+const inflightRequests = Object.create(null);
+const TRANSACTION_KEY_SEP = '::';
+const EMPTY_STRING = '';
+function isResourceRequestDedupable(resourceRequest) {
+    const resourceRequestContext = resourceRequest.resourceRequestContext;
+    return (resourceRequest.resourceRequest.method.toLowerCase() === 'get' ||
+        (resourceRequestContext && resourceRequestContext.luvioRequestMethod === 'get'));
+}
+function getTransactionKey(req) {
+    const { resourceRequest } = req;
+    const { baseUri, basePath, queryParams, headers } = resourceRequest;
+    const path = `${baseUri}${basePath}`;
+    const queryParamsString = queryParams ? stringify(queryParams) : EMPTY_STRING;
+    const headersString = stringify(headers);
+    const bodyString = resourceRequest.body && isResourceRequestDedupable(req)
+        ? stringify(resourceRequest.body)
+        : EMPTY_STRING;
+    return `${path}${TRANSACTION_KEY_SEP}${headersString}${TRANSACTION_KEY_SEP}${queryParamsString}${bodyString}`;
+}
+function getFulfillingRequest(inflightRequests, resourceRequest) {
+    const { fulfill } = resourceRequest;
+    if (fulfill === undefined) {
+        return null;
+    }
+    const handlersMap = entries(inflightRequests);
+    for (let i = 0, len = handlersMap.length; i < len; i += 1) {
+        const [transactionKey, handlers] = handlersMap[i];
+        // check fulfillment against only the first handler ([0]) because it's equal or
+        // fulfills all subsequent handlers in the array
+        const existing = handlers[0].resourceRequest;
+        if (fulfill(existing, resourceRequest) === true) {
+            return transactionKey;
+        }
+    }
+    return null;
+}
+/**
+  Dedupes network requests being made to Salesforce APIs
+  This function is only designed to dedupe GET requests.
 
-  If POST/PUT/PATCH/DELETE requests need to be deduped, that should be handled
-  on the server instead of here.
-*/
-const dedupeRequest = (req) => {
-    const { resourceRequest } = req;
-    if (process.env.NODE_ENV !== 'production') {
-        if (!isResourceRequestDedupable(req)) {
-            throw new Error('Invalid ResourceRequest that cannot be deduped. Only "get" Requests supported.');
-        }
-    }
-    const transactionKey = getTransactionKey(req);
-    // if an identical request is in-flight then queue for its response (do not re-issue the request)
-    if (transactionKey in inflightRequests) {
-        return new Promise((resolve, reject) => {
-            push.call(inflightRequests[transactionKey], {
-                resolve,
-                reject,
-                resourceRequest,
-            });
-        });
-    }
-    const dispatch = getDispatcher(resourceRequest);
-    // fallback to checking a custom deduper to find a similar (but not identical) request
-    const similarTransactionKey = getFulfillingRequest(inflightRequests, resourceRequest);
-    if (similarTransactionKey !== null) {
-        return new Promise((resolve) => {
-            // custom dedupers find similar (not identical) requests. if the similar request fails
-            // there's no guarantee the deduped request should fail. thus we re-issue the
-            // original request in the case of a failure
-            push.call(inflightRequests[similarTransactionKey], {
-                resolve,
-                reject: function reissueRequest() {
-                    resolve(dispatch(req));
-                },
-                resourceRequest,
-            });
-        });
-    }
-    dispatch(req).then((response) => {
-        const handlers = inflightRequests[transactionKey];
-        delete inflightRequests[transactionKey];
-        // handlers mutate responses so must clone the response for each.
-        // the first handler is given the original version to avoid an
-        // extra clone (particularly when there's only 1 handler).
-        for (let i = 1, len = handlers.length; i < len; i++) {
-            const handler = handlers[i];
-            handler.resolve(parse(stringify(response)));
-        }
-        handlers[0].resolve(response);
-    }, (error) => {
-        const handlers = inflightRequests[transactionKey];
-        delete inflightRequests[transactionKey];
-        for (let i = 0, len = handlers.length; i < len; i++) {
-            const handler = handlers[i];
-            handler.reject(error);
-        }
-    });
-    // rely on sync behavior of Promise creation to create the list for handlers
-    return new Promise((resolve, reject) => {
-        inflightRequests[transactionKey] = [{ resolve, reject, resourceRequest }];
-    });
+  If POST/PUT/PATCH/DELETE requests need to be deduped, that should be handled
+  on the server instead of here.
+*/
+const dedupeRequest = (req) => {
+    const { resourceRequest } = req;
+    if (process.env.NODE_ENV !== 'production') {
+        if (!isResourceRequestDedupable(req)) {
+            throw new Error('Invalid ResourceRequest that cannot be deduped. Only "get" Requests supported.');
+        }
+    }
+    const transactionKey = getTransactionKey(req);
+    // if an identical request is in-flight then queue for its response (do not re-issue the request)
+    if (transactionKey in inflightRequests) {
+        return new Promise((resolve, reject) => {
+            push.call(inflightRequests[transactionKey], {
+                resolve,
+                reject,
+                resourceRequest,
+            });
+        });
+    }
+    const dispatch = getDispatcher(resourceRequest);
+    // fallback to checking a custom deduper to find a similar (but not identical) request
+    const similarTransactionKey = getFulfillingRequest(inflightRequests, resourceRequest);
+    if (similarTransactionKey !== null) {
+        return new Promise((resolve) => {
+            // custom dedupers find similar (not identical) requests. if the similar request fails
+            // there's no guarantee the deduped request should fail. thus we re-issue the
+            // original request in the case of a failure
+            push.call(inflightRequests[similarTransactionKey], {
+                resolve,
+                reject: function reissueRequest() {
+                    resolve(dispatch(req));
+                },
+                resourceRequest,
+            });
+        });
+    }
+    dispatch(req).then((response) => {
+        const handlers = inflightRequests[transactionKey];
+        delete inflightRequests[transactionKey];
+        // handlers mutate responses so must clone the response for each.
+        // the first handler is given the original version to avoid an
+        // extra clone (particularly when there's only 1 handler).
+        for (let i = 1, len = handlers.length; i < len; i++) {
+            const handler = handlers[i];
+            handler.resolve(parse(stringify(response)));
+        }
+        handlers[0].resolve(response);
+    }, (error) => {
+        const handlers = inflightRequests[transactionKey];
+        delete inflightRequests[transactionKey];
+        for (let i = 0, len = handlers.length; i < len; i++) {
+            const handler = handlers[i];
+            handler.reject(error);
+        }
+    });
+    // rely on sync behavior of Promise creation to create the list for handlers
+    return new Promise((resolve, reject) => {
+        inflightRequests[transactionKey] = [{ resolve, reject, resourceRequest }];
+    });
 };
 
-const RATE_LIMIT_CONFIG = {
-    bucketCapacity: 100,
-    fillsPerSecond: 100,
-};
-class TokenBucket {
-    /**
-     * Constructs an instance of Token Bucket for rate limiting
-     *
-     * @param bucket The token holding capacity of the bucket
-     * @param refillTokensPerSecond The number of tokens replenished every second
-     */
-    constructor(config) {
-        this.bucketCapacity = config.bucketCapacity;
-        this.refillTokensPerMilliSecond = config.fillsPerSecond / 1000;
-        this.tokens = config.bucketCapacity;
-        this.lastRefillTime = Date.now();
-    }
-    /**
-     * Refills the bucket and removes desired number of tokens
-     *
-     * @param removeTokens number of tokens to be removed from the bucket should be >= 0
-     * @returns {boolean} true if removing token was succesful
-     */
-    take(removeTokens) {
-        // refill tokens before removing
-        this.refill();
-        const { tokens } = this;
-        const remainingTokens = tokens - removeTokens;
-        if (remainingTokens >= 0) {
-            this.tokens = remainingTokens;
-            return true;
-        }
-        return false;
-    }
-    refill() {
-        const { bucketCapacity, tokens, refillTokensPerMilliSecond, lastRefillTime } = this;
-        const now = Date.now();
-        const timePassed = now - lastRefillTime;
-        // Number of tokens should be integer so something like Math.floor is desired
-        // Using Bitwise NOT ~ twice will achieve the same result with performance benefits
-        const calculatedTokens = tokens + ~~(timePassed * refillTokensPerMilliSecond);
-        this.tokens = bucketCapacity < calculatedTokens ? bucketCapacity : calculatedTokens;
-        this.lastRefillTime = now;
-    }
-}
+const RATE_LIMIT_CONFIG = {
+    bucketCapacity: 100,
+    fillsPerSecond: 100,
+};
+class TokenBucket {
+    /**
+     * Constructs an instance of Token Bucket for rate limiting
+     *
+     * @param bucket The token holding capacity of the bucket
+     * @param refillTokensPerSecond The number of tokens replenished every second
+     */
+    constructor(config) {
+        this.bucketCapacity = config.bucketCapacity;
+        this.refillTokensPerMilliSecond = config.fillsPerSecond / 1000;
+        this.tokens = config.bucketCapacity;
+        this.lastRefillTime = Date.now();
+    }
+    /**
+     * Refills the bucket and removes desired number of tokens
+     *
+     * @param removeTokens number of tokens to be removed from the bucket should be >= 0
+     * @returns {boolean} true if removing token was succesful
+     */
+    take(removeTokens) {
+        // refill tokens before removing
+        this.refill();
+        const { tokens } = this;
+        const remainingTokens = tokens - removeTokens;
+        if (remainingTokens >= 0) {
+            this.tokens = remainingTokens;
+            return true;
+        }
+        return false;
+    }
+    refill() {
+        const { bucketCapacity, tokens, refillTokensPerMilliSecond, lastRefillTime } = this;
+        const now = Date.now();
+        const timePassed = now - lastRefillTime;
+        // Number of tokens should be integer so something like Math.floor is desired
+        // Using Bitwise NOT ~ twice will achieve the same result with performance benefits
+        const calculatedTokens = tokens + ~~(timePassed * refillTokensPerMilliSecond);
+        this.tokens = bucketCapacity < calculatedTokens ? bucketCapacity : calculatedTokens;
+        this.lastRefillTime = now;
+    }
+}
 var tokenBucket = new TokenBucket(RATE_LIMIT_CONFIG);
 
-function platformNetworkAdapter(baseNetworkAdapter) {
-    return (resourceRequest, resourceRequestContext) => {
-        if (!tokenBucket.take(1)) {
-            // We are hitting rate limiting, add some metrics
-            instrumentation.networkRateLimitExceeded();
-        }
-        const salesforceRequest = {
-            networkAdapter: baseNetworkAdapter,
-            resourceRequest: resourceRequest,
-            resourceRequestContext: resourceRequestContext,
-        };
-        // If GET, or overriden to be treated as a GET with resourceRequestContext.networkResourceOverride, then dedupe.
-        if (isResourceRequestDedupable(salesforceRequest)) {
-            return dedupeRequest(salesforceRequest);
-        }
-        else {
-            const dispatch = getDispatcher(resourceRequest);
-            return dispatch(salesforceRequest);
-        }
-    };
+function platformNetworkAdapter(baseNetworkAdapter) {
+    return (resourceRequest, resourceRequestContext) => {
+        if (!tokenBucket.take(1)) {
+            // We are hitting rate limiting, add some metrics
+            instrumentation.networkRateLimitExceeded();
+        }
+        const salesforceRequest = {
+            networkAdapter: baseNetworkAdapter,
+            resourceRequest: resourceRequest,
+            resourceRequestContext: resourceRequestContext,
+        };
+        // If GET, or overriden to be treated as a GET with resourceRequestContext.networkResourceOverride, then dedupe.
+        if (isResourceRequestDedupable(salesforceRequest)) {
+            return dedupeRequest(salesforceRequest);
+        }
+        else {
+            const dispatch = getDispatcher(resourceRequest);
+            return dispatch(salesforceRequest);
+        }
+    };
 }
 
 export { platformNetworkAdapter as default, instrument };

package/dist/{dispatch → types/dispatch}/dedupe.d.ts

@@ -1,10 +1,10 @@
-import type { Dispatcher, SalesforceResourceRequest } from './main';
-export declare function isResourceRequestDedupable(resourceRequest: SalesforceResourceRequest): boolean;
-/**
-  Dedupes network requests being made to Salesforce APIs
-  This function is only designed to dedupe GET requests.
+import type { Dispatcher, SalesforceResourceRequest } from './main';
+export declare function isResourceRequestDedupable(resourceRequest: SalesforceResourceRequest): boolean;
+/**
+  Dedupes network requests being made to Salesforce APIs
+  This function is only designed to dedupe GET requests.
 
-  If POST/PUT/PATCH/DELETE requests need to be deduped, that should be handled
-  on the server instead of here.
-*/
-export declare const dedupeRequest: Dispatcher;
+  If POST/PUT/PATCH/DELETE requests need to be deduped, that should be handled
+  on the server instead of here.
+*/
+export declare const dedupeRequest: Dispatcher;

package/dist/{dispatch → types/dispatch}/execute-aggregate-ui.d.ts

@@ -1,26 +1,26 @@
-import type { FetchResponse, NetworkAdapter, ResourceRequest, ResourceRequestContext } from '@luvio/engine';
-import type { RecordRepresentation } from '@salesforce/lds-adapters-uiapi';
-export declare const MAX_AGGREGATE_UI_CHUNK_LIMIT = 50;
-export interface CompositeRequest {
-    url: string;
-    referenceId: string;
-}
-export declare function mergeRecordFields(first: RecordRepresentation, second: RecordRepresentation): RecordRepresentation;
-/** Invoke executeAggregateUi Aura controller.  This is only to be used with large getRecord requests that
- *  would otherwise cause a query length exception.
- */
-export declare function dispatchSplitRecordAggregateUiAction(recordId: string, networkAdapter: NetworkAdapter, resourceRequest: ResourceRequest, resourceRequestContext: ResourceRequestContext): Promise<FetchResponse<unknown>>;
-export declare function shouldUseAggregateUiForGetRecord(fieldsArray: string, optionalFieldsArray: string): boolean;
-interface AggregateUiParams {
-    fields?: string[];
-    optionalFields?: string[];
-}
-export declare function buildAggregateUiUrl(params: AggregateUiParams, resourceRequest: ResourceRequest): string;
-export interface GetRecordCompositeRequestParams {
-    fieldsArray: Array<string>;
-    optionalFieldsArray: Array<string>;
-    fieldsLength: number;
-    optionalFieldsLength: number;
-}
-export declare function buildGetRecordByFieldsCompositeRequest(resourceRequest: ResourceRequest, recordsCompositeRequest: GetRecordCompositeRequestParams): CompositeRequest[];
-export {};
+import type { FetchResponse, NetworkAdapter, ResourceRequest, ResourceRequestContext } from '@luvio/engine';
+import type { RecordRepresentation } from '@salesforce/lds-adapters-uiapi';
+export declare const MAX_AGGREGATE_UI_CHUNK_LIMIT = 50;
+export interface CompositeRequest {
+    url: string;
+    referenceId: string;
+}
+export declare function mergeRecordFields(first: RecordRepresentation, second: RecordRepresentation): RecordRepresentation;
+/** Invoke executeAggregateUi Aura controller.  This is only to be used with large getRecord requests that
+ *  would otherwise cause a query length exception.
+ */
+export declare function dispatchSplitRecordAggregateUiAction(recordId: string, networkAdapter: NetworkAdapter, resourceRequest: ResourceRequest, resourceRequestContext: ResourceRequestContext): Promise<FetchResponse<unknown>>;
+export declare function shouldUseAggregateUiForGetRecord(fieldsArray: string, optionalFieldsArray: string): boolean;
+interface AggregateUiParams {
+    fields?: string[];
+    optionalFields?: string[];
+}
+export declare function buildAggregateUiUrl(params: AggregateUiParams, resourceRequest: ResourceRequest): string;
+export interface GetRecordCompositeRequestParams {
+    fieldsArray: Array<string>;
+    optionalFieldsArray: Array<string>;
+    fieldsLength: number;
+    optionalFieldsLength: number;
+}
+export declare function buildGetRecordByFieldsCompositeRequest(resourceRequest: ResourceRequest, recordsCompositeRequest: GetRecordCompositeRequestParams): CompositeRequest[];
+export {};

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

@@ -1,9 +1,9 @@
-import type { FetchResponse, NetworkAdapter, ResourceRequest, ResourceRequestContext } from '@luvio/engine';
-export interface SalesforceResourceRequest {
-    networkAdapter: NetworkAdapter;
-    resourceRequest: ResourceRequest;
-    resourceRequestContext: ResourceRequestContext;
-}
-export type Dispatcher = (req: SalesforceResourceRequest) => Promise<FetchResponse<unknown>>;
-export declare const defaultDispatcher: Dispatcher;
-export declare function getDispatcher(resourceRequest: ResourceRequest): Dispatcher;
+import type { FetchResponse, NetworkAdapter, ResourceRequest, ResourceRequestContext } from '@luvio/engine';
+export interface SalesforceResourceRequest {
+    networkAdapter: NetworkAdapter;
+    resourceRequest: ResourceRequest;
+    resourceRequestContext: ResourceRequestContext;
+}
+export type Dispatcher = (req: SalesforceResourceRequest) => Promise<FetchResponse<unknown>>;
+export declare const defaultDispatcher: Dispatcher;
+export declare function getDispatcher(resourceRequest: ResourceRequest): Dispatcher;

package/dist/{dispatch → types/dispatch}/records.d.ts

@@ -1,3 +1,3 @@
-import type { ResourceRequest } from '@luvio/engine';
-import type { Dispatcher } from './main';
-export declare function matchRecordsHandlers(path: string, resourceRequest: ResourceRequest): Dispatcher | null;
+import type { ResourceRequest } from '@luvio/engine';
+import type { Dispatcher } from './main';
+export declare function matchRecordsHandlers(path: string, resourceRequest: ResourceRequest): Dispatcher | null;

package/dist/{dispatch → types/dispatch}/related-lists.d.ts

@@ -1,3 +1,3 @@
-import type { ResourceRequest } from '@luvio/engine';
-export declare function isRelatedListPostRecordsResourceRequest(resourceRequest: ResourceRequest): boolean;
-export declare function convertPostRelatedListRecordsToGet(resourceRequest: ResourceRequest): ResourceRequest;
+import type { ResourceRequest } from '@luvio/engine';
+export declare function isRelatedListPostRecordsResourceRequest(resourceRequest: ResourceRequest): boolean;
+export declare function convertPostRelatedListRecordsToGet(resourceRequest: ResourceRequest): ResourceRequest;

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

@@ -1,17 +1,17 @@
-import type { ResourceRequest } from '@luvio/engine';
-export declare let instrumentation: {
-    aggregateUiChunkCount: (_cb: () => number) => void;
-    aggregateUiConnectError: () => void;
-    duplicateRequest: (_cb: () => ResourceRequest) => void;
-    getRecordAggregateInvoke: () => void;
-    getRecordAggregateResolve: (_cb: () => {
-        recordId: string;
-        apiName: string;
-    }) => void;
-    getRecordAggregateReject: (_cb: () => string) => void;
-    getRecordAggregateRetry: () => void;
-    getRecordNormalInvoke: () => void;
-    networkRateLimitExceeded: () => void;
-};
-export declare function instrument(newInstrumentation: Partial<typeof instrumentation>): void;
-export type Instrument = typeof instrument;
+import type { ResourceRequest } from '@luvio/engine';
+export declare let instrumentation: {
+    aggregateUiChunkCount: (_cb: () => number) => void;
+    aggregateUiConnectError: () => void;
+    duplicateRequest: (_cb: () => ResourceRequest) => void;
+    getRecordAggregateInvoke: () => void;
+    getRecordAggregateResolve: (_cb: () => {
+        recordId: string;
+        apiName: string;
+    }) => void;
+    getRecordAggregateReject: (_cb: () => string) => void;
+    getRecordAggregateRetry: () => void;
+    getRecordNormalInvoke: () => void;
+    networkRateLimitExceeded: () => void;
+};
+export declare function instrument(newInstrumentation: Partial<typeof instrumentation>): void;
+export type Instrument = typeof instrument;

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

@@ -1,16 +1,16 @@
-declare const parse: (text: string, reviver?: ((this: any, key: string, value: any) => any) | undefined) => any, stringify: {
-    (value: any, replacer?: ((this: any, key: string, value: any) => any) | undefined, space?: string | number | undefined): string;
-    (value: any, replacer?: (string | number)[] | null | undefined, space?: string | number | undefined): string;
-};
-declare const join: (separator?: string | undefined) => string, push: (...items: any[]) => number, unshift: (...items: any[]) => number;
-declare const isArray: (arg: any) => arg is any[];
-declare const entries: {
-    <T>(o: {
-        [s: string]: T;
-    } | ArrayLike<T>): [string, T][];
-    (o: {}): [string, any][];
-}, keys: {
-    (o: object): string[];
-    (o: {}): string[];
-};
-export { isArray as ArrayIsArray, entries as ObjectEntries, keys as ObjectKeys, parse as JSONParse, stringify as JSONStringify, join as ArrayPrototypeJoin, push as ArrayPrototypePush, unshift as ArrayPrototypeUnshift, };
+declare const parse: (text: string, reviver?: ((this: any, key: string, value: any) => any) | undefined) => any, stringify: {
+    (value: any, replacer?: ((this: any, key: string, value: any) => any) | undefined, space?: string | number | undefined): string;
+    (value: any, replacer?: (string | number)[] | null | undefined, space?: string | number | undefined): string;
+};
+declare const join: (separator?: string | undefined) => string, push: (...items: any[]) => number, unshift: (...items: any[]) => number;
+declare const isArray: (arg: any) => arg is any[];
+declare const entries: {
+    <T>(o: {
+        [s: string]: T;
+    } | ArrayLike<T>): [string, T][];
+    (o: {}): [string, any][];
+}, keys: {
+    (o: object): string[];
+    (o: {}): string[];
+};
+export { isArray as ArrayIsArray, entries as ObjectEntries, keys as ObjectKeys, parse as JSONParse, stringify as JSONStringify, join as ArrayPrototypeJoin, push as ArrayPrototypePush, unshift as ArrayPrototypeUnshift, };

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

@@ -1,8 +1,8 @@
-import type { NetworkAdapter } from '@luvio/engine';
-import type { Instrument } from './instrumentation';
-export { instrument, Instrument } from './instrumentation';
-export default function platformNetworkAdapter(baseNetworkAdapter: NetworkAdapter): NetworkAdapter;
-export type Registration = {
-    id: '@salesforce/lds-network-adapter';
-    instrument: Instrument;
-};
+import type { NetworkAdapter } from '@luvio/engine';
+import type { Instrument } from './instrumentation';
+export { instrument, Instrument } from './instrumentation';
+export default function platformNetworkAdapter(baseNetworkAdapter: NetworkAdapter): NetworkAdapter;
+export type Registration = {
+    id: '@salesforce/lds-network-adapter';
+    instrument: Instrument;
+};

package/dist/{token-bucket.d.ts → types/token-bucket.d.ts}

@@ -1,28 +1,28 @@
-interface RateLimitConfig {
-    bucketCapacity: number;
-    fillsPerSecond: number;
-}
-export declare const RATE_LIMIT_CONFIG: RateLimitConfig;
-export declare class TokenBucket {
-    bucketCapacity: number;
-    readonly refillTokensPerMilliSecond: number;
-    tokens: number;
-    private lastRefillTime;
-    /**
-     * Constructs an instance of Token Bucket for rate limiting
-     *
-     * @param bucket The token holding capacity of the bucket
-     * @param refillTokensPerSecond The number of tokens replenished every second
-     */
-    constructor(config: RateLimitConfig);
-    /**
-     * Refills the bucket and removes desired number of tokens
-     *
-     * @param removeTokens number of tokens to be removed from the bucket should be >= 0
-     * @returns {boolean} true if removing token was succesful
-     */
-    take(removeTokens: number): boolean;
-    private refill;
-}
-declare const _default: TokenBucket;
-export default _default;
+interface RateLimitConfig {
+    bucketCapacity: number;
+    fillsPerSecond: number;
+}
+export declare const RATE_LIMIT_CONFIG: RateLimitConfig;
+export declare class TokenBucket {
+    bucketCapacity: number;
+    readonly refillTokensPerMilliSecond: number;
+    tokens: number;
+    private lastRefillTime;
+    /**
+     * Constructs an instance of Token Bucket for rate limiting
+     *
+     * @param bucket The token holding capacity of the bucket
+     * @param refillTokensPerSecond The number of tokens replenished every second
+     */
+    constructor(config: RateLimitConfig);
+    /**
+     * Refills the bucket and removes desired number of tokens
+     *
+     * @param removeTokens number of tokens to be removed from the bucket should be >= 0
+     * @returns {boolean} true if removing token was succesful
+     */
+    take(removeTokens: number): boolean;
+    private refill;
+}
+declare const _default: TokenBucket;
+export default _default;

package/dist/{uiapi-base.d.ts → types/uiapi-base.d.ts}

@@ -1 +1 @@
-export declare const UI_API_BASE_URI = "/services/data/v58.0/ui-api";
+export declare const UI_API_BASE_URI = "/services/data/v58.0/ui-api";

package/package.json

@@ -1,18 +1,18 @@
 {
     "name": "@salesforce/lds-network-adapter",
-    "version": "1.124.2",
+    "version": "1.124.3",
     "license": "SEE LICENSE IN LICENSE.txt",
     "description": "LDS shared Network Adapter code for Lightning Platform",
     "main": "dist/ldsNetwork.js",
     "module": "dist/ldsNetwork.js",
-    "types": "dist/main.d.ts",
+    "types": "dist/types/main.d.ts",
     "files": [
         "dist"
     ],
     "exports": {
         ".": {
             "import": "./dist/ldsNetwork.js",
-            "types": "./dist/main.d.ts",
+            "types": "./dist/types/main.d.ts",
             "default": "./dist/ldsNetwork.js"
         }
     },