@salesforce/lds-runtime-aura 1.245.0 → 1.247.0

package/dist/ldsEngineCreator.js

@@ -14,15 +14,703 @@
 /* proxy-compat-disable */
 import { HttpStatusCode, InMemoryStore, Environment, Luvio, InMemoryStoreQueryEvaluator } from 'force/luvioEngine';
 import ldsTrackedFieldsBehaviorGate from '@salesforce/gate/lds.useNewTrackedFieldBehavior';
-import { instrument, configuration, InMemoryRecordRepresentationQueryEvaluator, UiApiNamespace, RecordRepresentationRepresentationType } from 'force/ldsAdaptersUiapi';
+import usePredictiveLoading from '@salesforce/gate/lds.usePredictiveLoading';
+import { getRecordAvatarsAdapterFactory, getRecordAdapterFactory, getRecordsAdapterFactory, getRecordActionsAdapterFactory, instrument, configuration, InMemoryRecordRepresentationQueryEvaluator, UiApiNamespace, RecordRepresentationRepresentationType, registerPrefetcher } from 'force/ldsAdaptersUiapi';
+import { createStorage, clearStorages } from 'force/ldsStorage';
 import { withRegistration, register, setDefaultLuvio } from 'force/ldsEngine';
 import { REFRESH_ADAPTER_EVENT, ADAPTER_UNFULFILLED_ERROR, instrument as instrument$2 } from 'force/ldsBindings';
 import { counter, registerCacheStats, perfStart, perfEnd, registerPeriodicLogger, interaction, timer } from 'instrumentation/service';
-import { LRUCache, instrumentAdapter, instrumentLuvio, setupInstrumentation as setupInstrumentation$1, logObjectInfoChanged as logObjectInfoChanged$1, updatePercentileHistogramMetric, incrementCounterMetric, incrementGetRecordNotifyChangeAllowCount, incrementGetRecordNotifyChangeDropCount, incrementNotifyRecordUpdateAvailableAllowCount, incrementNotifyRecordUpdateAvailableDropCount, setLdsAdaptersUiapiInstrumentation, setLdsNetworkAdapterInstrumentation } from 'force/ldsInstrumentation';
+import { LRUCache, instrumentAdapter, instrumentLuvio, setupInstrumentation as setupInstrumentation$1, logObjectInfoChanged as logObjectInfoChanged$1, updatePercentileHistogramMetric, incrementCounterMetric, incrementGetRecordNotifyChangeAllowCount, incrementGetRecordNotifyChangeDropCount, incrementNotifyRecordUpdateAvailableAllowCount, incrementNotifyRecordUpdateAvailableDropCount, setLdsAdaptersUiapiInstrumentation, setLdsNetworkAdapterInstrumentation, onIdleDetected } from 'force/ldsInstrumentation';
 import auraNetworkAdapter, { instrument as instrument$1, forceRecordTransactionsDisabled, ldsNetworkAdapterInstrument, dispatchAuraAction, defaultActionConfig } from 'force/ldsNetwork';
 import { instrument as instrument$3 } from 'force/adsBridge';
 import { buildJwtNetworkAdapter } from 'force/ldsNetworkFetchWithJwt';
-import { clearStorages } from 'force/ldsStorage';
+
+class PredictivePrefetchPage {
+    constructor(context) {
+        this.context = context;
+        this.similarContext = undefined;
+    }
+}
+
+class LexDefaultPage extends PredictivePrefetchPage {
+    constructor(context) {
+        super(context);
+    }
+    buildSaveRequestData(request) {
+        return { context: this.context, request };
+    }
+    resolveSimilarRequest(similarRequest) {
+        return similarRequest;
+    }
+    getAlwaysRunRequests() {
+        return [];
+    }
+}
+
+class RecordHomePage extends PredictivePrefetchPage {
+    constructor(context, requestStrategies) {
+        super(context);
+        this.requestStrategies = requestStrategies;
+        const { recordId: _, ...rest } = this.context;
+        this.similarContext = {
+            recordId: '*',
+            ...rest,
+        };
+    }
+    buildSaveRequestData(request) {
+        const { adapterName } = request;
+        switch (adapterName) {
+            case 'getRecord':
+                return this.buildGetRecordSaveRequestData(request);
+            case 'getRecords':
+                return this.buildGetRecordsSaveRequestData(request);
+            case 'getRecordActions':
+                return this.requestStrategies.getRecordActions.buildGetRecordActionsSaveRequestData(this.similarContext, this.context, request);
+            case 'getRecordAvatars':
+                return this.requestStrategies.getRecordAvatars.buildGetRecordAvatarsSaveRequestData(this.similarContext, this.context, request);
+            default:
+                return { request, context: this.context };
+        }
+    }
+    buildGetRecordSaveRequestData(request) {
+        if (this.isGetRecordRequestContextDependent(request)) {
+            return {
+                request: this.requestStrategies.getRecord.transformForSave({
+                    ...request,
+                    config: {
+                        ...request.config,
+                        recordId: '*',
+                    },
+                }),
+                context: this.similarContext,
+            };
+        }
+        return {
+            request: this.requestStrategies.getRecord.transformForSave(request),
+            context: this.context,
+        };
+    }
+    buildGetRecordsSaveRequestData(request) {
+        if (this.isGetRecordsRequestContextDependent(request)) {
+            return {
+                request: this.requestStrategies.getRecords.transformForSave({
+                    ...request,
+                    config: {
+                        ...request.config,
+                        records: [
+                            {
+                                ...request.config.records[0],
+                                recordIds: ['*'],
+                            },
+                        ],
+                    },
+                }),
+                context: this.context,
+            };
+        }
+        return {
+            request: this.requestStrategies.getRecords.transformForSave(request),
+            context: this.context,
+        };
+    }
+    isGetRecordRequestContextDependent(request) {
+        return request.config.recordId === this.context.recordId;
+    }
+    isGetRecordsRequestContextDependent(request) {
+        const isSingleRecordRequest = request.config.records.length === 1 && request.config.records[0].recordIds.length === 1;
+        return (isSingleRecordRequest &&
+            request.config.records[0].recordIds[0] === this.context.recordId);
+    }
+    resolveSimilarRequest(similarRequest) {
+        if (similarRequest.adapterName === 'getRecord') {
+            return this.requestStrategies.getRecord.buildConcreteRequest(similarRequest, this.context);
+        }
+        if (similarRequest.adapterName === 'getRecords') {
+            return this.requestStrategies.getRecords.buildConcreteRequest(similarRequest, this.context);
+        }
+        if (similarRequest.adapterName === 'getRecordActions') {
+            return this.requestStrategies.getRecordActions.buildConcreteRequest(similarRequest, this.context);
+        }
+        if (similarRequest.adapterName === 'getRecordAvatars') {
+            return this.requestStrategies.getRecordAvatars.buildConcreteRequest(similarRequest, this.context);
+        }
+        return similarRequest;
+    }
+    // Record Home performs best when we always do a minimal getRecord alongside the other requests.
+    getAlwaysRunRequests() {
+        const { recordId, objectApiName } = this.context;
+        return [
+            {
+                adapterName: 'getRecord',
+                config: {
+                    recordId,
+                    optionalFields: [`${objectApiName}.Id`, `${objectApiName}.RecordTypeId`],
+                },
+            },
+        ];
+    }
+    static handlesContext(context) {
+        const maybeRecordHomePageContext = context;
+        return (maybeRecordHomePageContext !== undefined &&
+            maybeRecordHomePageContext.actionName !== undefined &&
+            maybeRecordHomePageContext.objectApiName !== undefined &&
+            maybeRecordHomePageContext.recordId !== undefined &&
+            maybeRecordHomePageContext.type === 'recordPage');
+    }
+}
+
+class ApplicationPredictivePrefetcher {
+    constructor(context, repository, requestRunner) {
+        this.repository = repository;
+        this.requestRunner = requestRunner;
+        this.isRecording = false;
+        this.queuedPredictionRequests = [];
+        this._context = context;
+        this.page = this.getPage();
+    }
+    set context(value) {
+        this._context = value;
+        this.page = this.getPage();
+    }
+    get context() {
+        return this._context;
+    }
+    async stopRecording() {
+        this.isRecording = false;
+        await this.repository.flushRequestsToStorage();
+    }
+    startRecording() {
+        this.isRecording = true;
+        this.repository.clearRequestBuffer();
+    }
+    saveRequest(request) {
+        if (!this.isRecording) {
+            return Promise.resolve();
+        }
+        const { request: requestToSave, context } = this.page.buildSaveRequestData(request);
+        // No need to diferentiate from predictions requests because these
+        // are made from the adapters factory, which are not prediction aware.
+        return this.repository.saveRequest(context, requestToSave);
+    }
+    async predict() {
+        const exactPageRequests = (await this.repository.getPageRequests(this.context)) || [];
+        const similarPageRequests = await this.getSimilarPageRequests();
+        const predictedRequests = [
+            ...this.requestRunner.reduceRequests([...exactPageRequests, ...similarPageRequests]),
+            ...this.page.getAlwaysRunRequests(),
+        ];
+        this.queuedPredictionRequests.push(...predictedRequests);
+        return Promise.all(predictedRequests.map((request) => this.requestRunner.runRequest(request))).then();
+    }
+    async getSimilarPageRequests() {
+        let resolvedSimilarPageRequests = [];
+        if (this.page.similarContext !== undefined) {
+            const similarPageRequests = await this.repository.getPageRequests(this.page.similarContext);
+            if (similarPageRequests !== undefined) {
+                resolvedSimilarPageRequests = similarPageRequests.map((request) => this.page.resolveSimilarRequest(request));
+            }
+        }
+        return resolvedSimilarPageRequests;
+    }
+}
+
+class LexPredictivePrefetcher extends ApplicationPredictivePrefetcher {
+    constructor(context, repository, requestRunner, 
+    // These strategies need to be in sync with the "predictiveDataLoadCapable" list
+    // from scripts/lds-uiapi-plugin.js
+    requestStrategies) {
+        super(context, repository, requestRunner);
+        this.requestStrategies = requestStrategies;
+        this.page = this.getPage();
+    }
+    getPage() {
+        if (RecordHomePage.handlesContext(this.context)) {
+            return new RecordHomePage(this.context, this.requestStrategies);
+        }
+        return new LexDefaultPage(this.context);
+    }
+}
+
+// Copy-pasted from adapter-utils. This util should be extracted from generated code and imported in prefetch repository.
+const { keys: ObjectKeys } = Object;
+const { stringify: JSONStringify } = JSON;
+const { isArray: ArrayIsArray } = Array;
+/**
+ * A deterministic JSON stringify implementation. Heavily adapted from https://github.com/epoberezkin/fast-json-stable-stringify.
+ * This is needed because insertion order for JSON.stringify(object) affects output:
+ * JSON.stringify({a: 1, b: 2})
+ *      "{"a":1,"b":2}"
+ * JSON.stringify({b: 2, a: 1})
+ *      "{"b":2,"a":1}"
+ * @param data Data to be JSON-stringified.
+ * @returns JSON.stringified value with consistent ordering of keys.
+ */
+function stableJSONStringify$1(node) {
+    // This is for Date values.
+    if (node && node.toJSON && typeof node.toJSON === 'function') {
+        // eslint-disable-next-line no-param-reassign
+        node = node.toJSON();
+    }
+    if (node === undefined) {
+        return;
+    }
+    if (typeof node === 'number') {
+        return isFinite(node) ? '' + node : 'null';
+    }
+    if (typeof node !== 'object') {
+        return JSONStringify(node);
+    }
+    let i;
+    let out;
+    if (ArrayIsArray(node)) {
+        out = '[';
+        for (i = 0; i < node.length; i++) {
+            if (i) {
+                out += ',';
+            }
+            out += stableJSONStringify$1(node[i]) || 'null';
+        }
+        return out + ']';
+    }
+    if (node === null) {
+        return 'null';
+    }
+    const keys = ObjectKeys(node).sort();
+    out = '';
+    for (i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        const value = stableJSONStringify$1(node[key]);
+        if (!value) {
+            continue;
+        }
+        if (out) {
+            out += ',';
+        }
+        out += JSONStringify(key) + ':' + value;
+    }
+    return '{' + out + '}';
+}
+function isObject(obj) {
+    return obj !== null && typeof obj === 'object';
+}
+function deepEquals(objA, objB) {
+    if (objA === objB)
+        return true;
+    if (objA instanceof Date && objB instanceof Date)
+        return objA.getTime() === objB.getTime();
+    // If one of them is not an object, they are not deeply equal
+    if (!isObject(objA) || !isObject(objB))
+        return false;
+    // Filter out keys set as undefined, we can compare undefined as equals.
+    const keysA = ObjectKeys(objA).filter((key) => objA[key] !== undefined);
+    const keysB = ObjectKeys(objB).filter((key) => objB[key] !== undefined);
+    // If the objects do not have the same set of keys, they are not deeply equal
+    if (keysA.length !== keysB.length)
+        return false;
+    for (const key of keysA) {
+        const valA = objA[key];
+        const valB = objB[key];
+        const areObjects = isObject(valA) && isObject(valB);
+        // If both values are objects, recursively compare them
+        if (areObjects && !deepEquals(valA, valB))
+            return false;
+        // If only one value is an object or if the values are not strictly equal, they are not deeply equal
+        if (!areObjects && valA !== valB)
+            return false;
+    }
+    return true;
+}
+
+class PrefetchRepository {
+    constructor(storage) {
+        this.storage = storage;
+        this.requestBuffer = new Map();
+    }
+    clearRequestBuffer() {
+        this.requestBuffer.clear();
+    }
+    async flushRequestsToStorage() {
+        for (const [id, batch] of this.requestBuffer) {
+            const rawPage = await this.storage.get(id);
+            const page = rawPage === undefined ? { id, requests: [] } : rawPage;
+            batch.forEach(({ request, requestTime }) => {
+                let existingRequestEntry = page.requests.find(({ request: storedRequest }) => deepEquals(storedRequest, request));
+                if (existingRequestEntry === undefined) {
+                    existingRequestEntry = { request, requestMetadata: { requestTimes: [] } };
+                    page.requests.push(existingRequestEntry);
+                }
+                existingRequestEntry.requestMetadata.requestTimes.push(requestTime);
+            });
+            await this.storage.set(id, page);
+        }
+        this.clearRequestBuffer();
+    }
+    async saveRequest(key, request) {
+        const identifier = stableJSONStringify$1(key);
+        const batchForKey = this.requestBuffer.get(identifier) || [];
+        batchForKey.push({
+            request,
+            requestTime: Date.now(),
+        });
+        this.requestBuffer.set(identifier, batchForKey);
+    }
+    async getPage(key) {
+        const identifier = stableJSONStringify$1(key);
+        const rawPage = await this.storage.get(identifier);
+        return rawPage;
+    }
+    async getPageRequests(key) {
+        const page = await this.getPage(key);
+        if (page === undefined) {
+            return [];
+        }
+        return page.requests.map((requestEntry) => requestEntry.request);
+    }
+}
+
+class RequestStrategy {
+    transformForSave(request) {
+        return request;
+    }
+    reduce(requests) {
+        return requests;
+    }
+}
+
+class LuvioAdapterRequestStrategy extends RequestStrategy {
+    transformForSave(request) {
+        return request;
+    }
+    filterRequests(unfilteredRequests) {
+        return unfilteredRequests.filter((request) => request.adapterName === this.adapterName);
+    }
+    reduce(unfilteredRequests) {
+        return this.filterRequests(unfilteredRequests);
+    }
+}
+
+function normalizeRecordIds$1(recordIds) {
+    if (!Array.isArray(recordIds)) {
+        return [recordIds];
+    }
+    return recordIds;
+}
+function canCombine$1(reqA, reqB) {
+    return reqA.formFactor === reqB.formFactor;
+}
+function combineRequests$1(reqA, reqB) {
+    const combined = { ...reqA };
+    combined.recordIds = Array.from(new Set([...normalizeRecordIds$1(reqA.recordIds), ...normalizeRecordIds$1(reqB.recordIds)]));
+    return combined;
+}
+class GetRecordAvatarsRequestStrategy extends LuvioAdapterRequestStrategy {
+    constructor() {
+        super(...arguments);
+        this.adapterName = 'getRecordAvatars';
+        this.adapterFactory = getRecordAvatarsAdapterFactory;
+    }
+    buildConcreteRequest(similarRequest, context) {
+        return {
+            ...similarRequest,
+            config: {
+                ...similarRequest.config,
+                recordIds: [context.recordId],
+            },
+        };
+    }
+    buildGetRecordAvatarsSaveRequestData(similarContext, context, request) {
+        if (this.isGetRecordAvatarsRequestContextDependent(context, request)) {
+            return {
+                request: this.transformForSave({
+                    ...request,
+                    config: {
+                        ...request.config,
+                        recordIds: ['*'],
+                    },
+                }),
+                context: similarContext,
+            };
+        }
+        return {
+            request: this.transformForSave(request),
+            context,
+        };
+    }
+    isGetRecordAvatarsRequestContextDependent(context, request) {
+        return (request.config.recordIds &&
+            (context.recordId === request.config.recordIds || // some may set this as string instead of array
+                (request.config.recordIds.length === 1 &&
+                    request.config.recordIds[0] === context.recordId)));
+    }
+    reduce(unfilteredRequests) {
+        const requests = this.filterRequests(unfilteredRequests);
+        const visitedRequests = new Set();
+        const reducedRequests = [];
+        for (let i = 0, n = requests.length; i < n; i++) {
+            const currentRequest = requests[i];
+            if (!visitedRequests.has(currentRequest)) {
+                const combinedRequest = { ...currentRequest };
+                for (let j = i + 1; j < n; j++) {
+                    const hasNotBeenVisited = !visitedRequests.has(requests[j]);
+                    const canCombineConfigs = canCombine$1(combinedRequest.config, requests[j].config);
+                    if (hasNotBeenVisited && canCombineConfigs) {
+                        combinedRequest.config = combineRequests$1(combinedRequest.config, requests[j].config);
+                        visitedRequests.add(requests[j]);
+                    }
+                }
+                reducedRequests.push(combinedRequest);
+                visitedRequests.add(currentRequest);
+            }
+        }
+        return reducedRequests;
+    }
+}
+
+class GetRecordRequestStrategy extends LuvioAdapterRequestStrategy {
+    constructor() {
+        super(...arguments);
+        this.adapterName = 'getRecord';
+        this.adapterFactory = getRecordAdapterFactory;
+    }
+    buildConcreteRequest(similarRequest, context) {
+        return {
+            ...similarRequest,
+            config: {
+                ...similarRequest.config,
+                recordId: context.recordId,
+            },
+        };
+    }
+    transformForSave(request) {
+        if (request.config.fields === undefined && request.config.optionalFields === undefined) {
+            return request;
+        }
+        let optionalFields = request.config.optionalFields || [];
+        if (!ArrayIsArray(optionalFields)) {
+            optionalFields = [optionalFields];
+        }
+        return {
+            ...request,
+            config: {
+                ...request.config,
+                fields: undefined,
+                optionalFields: [...(request.config.fields || []), ...optionalFields],
+            },
+        };
+    }
+    reduce(unfilteredRequests) {
+        const requests = this.filterRequests(unfilteredRequests);
+        const recordIdToRequestMap = {};
+        const resultRequests = [];
+        requests.forEach((request) => {
+            if (request.config.fields === undefined &&
+                request.config.optionalFields === undefined) {
+                resultRequests.push(request);
+                return;
+            }
+            if (recordIdToRequestMap[request.config.recordId] === undefined) {
+                recordIdToRequestMap[request.config.recordId] = [];
+            }
+            recordIdToRequestMap[request.config.recordId].push(request);
+        });
+        Object.entries(recordIdToRequestMap).forEach(([recordId, requests]) => {
+            const fields = new Set();
+            const optionalFields = new Set();
+            requests.forEach((request) => {
+                if (request.config.fields !== undefined) {
+                    request.config.fields.forEach((field) => {
+                        fields.add(field);
+                    });
+                }
+                if (request.config.optionalFields !== undefined) {
+                    request.config.optionalFields.forEach((field) => {
+                        optionalFields.add(field);
+                    });
+                }
+            });
+            resultRequests.push({
+                adapterName: 'getRecord',
+                config: {
+                    recordId,
+                    fields: Array.from(fields),
+                    optionalFields: Array.from(optionalFields),
+                },
+            });
+        });
+        return resultRequests;
+    }
+}
+
+class GetRecordsRequestStrategy extends LuvioAdapterRequestStrategy {
+    constructor() {
+        super(...arguments);
+        this.adapterName = 'getRecords';
+        this.adapterFactory = getRecordsAdapterFactory;
+    }
+    buildConcreteRequest(similarRequest, context) {
+        return {
+            ...similarRequest,
+            config: {
+                ...similarRequest.config,
+                records: [{ ...similarRequest.config.records[0], recordIds: [context.recordId] }],
+            },
+        };
+    }
+}
+
+function normalizeRecordIds(recordIds) {
+    if (!Array.isArray(recordIds)) {
+        return [recordIds];
+    }
+    return recordIds;
+}
+function canCombine(reqA, reqB) {
+    return (reqA.retrievalMode === reqB.retrievalMode &&
+        reqA.formFactor === reqB.formFactor &&
+        (reqA.actionTypes || []).toString() === (reqB.actionTypes || []).toString() &&
+        (reqA.sections || []).toString() === (reqB.sections || []).toString());
+}
+function combineRequests(reqA, reqB) {
+    const combined = { ...reqA };
+    // let's merge the recordIds
+    combined.recordIds = Array.from(new Set([...normalizeRecordIds(reqA.recordIds), ...normalizeRecordIds(reqB.recordIds)]));
+    if (combined.retrievalMode === 'ALL') {
+        const combinedSet = new Set([...(combined.apiNames || []), ...(reqB.apiNames || [])]);
+        combined.apiNames = Array.from(combinedSet);
+    }
+    return combined;
+}
+class GetRecordActionsRequestStrategy extends LuvioAdapterRequestStrategy {
+    constructor() {
+        super(...arguments);
+        this.adapterName = 'getRecordActions';
+        this.adapterFactory = getRecordActionsAdapterFactory;
+    }
+    buildConcreteRequest(similarRequest, context) {
+        return {
+            ...similarRequest,
+            config: {
+                ...similarRequest.config,
+                recordIds: [context.recordId],
+            },
+        };
+    }
+    buildGetRecordActionsSaveRequestData(similarContext, context, request) {
+        if (this.isGetRecordActionsRequestContextDependent(context, request)) {
+            return {
+                request: this.transformForSave({
+                    ...request,
+                    config: {
+                        ...request.config,
+                        recordIds: ['*'],
+                    },
+                }),
+                context: similarContext,
+            };
+        }
+        return {
+            request: this.transformForSave(request),
+            context,
+        };
+    }
+    isGetRecordActionsRequestContextDependent(context, request) {
+        return (request.config.recordIds &&
+            (context.recordId === request.config.recordIds || // some may set this as string instead of array
+                (request.config.recordIds.length === 1 &&
+                    request.config.recordIds[0] === context.recordId)));
+    }
+    reduce(unfilteredRequests) {
+        const requests = this.filterRequests(unfilteredRequests);
+        const visitedRequests = new Set();
+        const reducedRequests = [];
+        for (let i = 0, n = requests.length; i < n; i++) {
+            const currentRequest = requests[i];
+            if (!visitedRequests.has(currentRequest)) {
+                const combinedRequest = { ...currentRequest };
+                for (let j = i + 1; j < n; j++) {
+                    if (!visitedRequests.has(requests[j]) &&
+                        canCombine(combinedRequest.config, requests[j].config)) {
+                        combinedRequest.config = combineRequests(combinedRequest.config, requests[j].config);
+                        visitedRequests.add(requests[j]);
+                    }
+                }
+                reducedRequests.push(combinedRequest);
+                visitedRequests.add(currentRequest);
+            }
+        }
+        return reducedRequests;
+    }
+}
+
+class LexRequestRunner {
+    constructor(luvio) {
+        this.luvio = luvio;
+        this.requestStrategies = {
+            getRecord: new GetRecordRequestStrategy(),
+            getRecords: new GetRecordsRequestStrategy(),
+            getRecordActions: new GetRecordActionsRequestStrategy(),
+            getRecordAvatars: new GetRecordAvatarsRequestStrategy(),
+        };
+    }
+    reduceRequests(requests) {
+        return Object.values(this.requestStrategies)
+            .map((strategy) => strategy.reduce(requests))
+            .flat();
+    }
+    runRequest(request) {
+        if (request.adapterName in this.requestStrategies) {
+            const adapterFactory = this.requestStrategies[request.adapterName].adapterFactory;
+            return Promise.resolve(adapterFactory(this.luvio)(request.config)).then();
+        }
+        return Promise.resolve(undefined);
+    }
+}
+
+class InMemoryPrefetchStorage {
+    constructor() {
+        this.data = {};
+    }
+    set(key, value) {
+        this.data[key] = value;
+        return Promise.resolve();
+    }
+    get(key) {
+        return Promise.resolve(this.data[key]);
+    }
+}
+
+const DEFAULT_STORAGE_OPTIONS = {
+    name: 'ldsPredictiveLoading',
+    persistent: true,
+    secure: true,
+    maxSize: 20 * 1024 * 1024,
+    // @todo: there's no way of setting a "no expire" value. We should determine the best ttl for this cache.
+    expiration: 24 * 60 * 60,
+    clearOnInit: false,
+    debugLogging: false,
+};
+function buildAuraPrefetchStorage(options = {}) {
+    const auraStorage = createStorage({
+        ...DEFAULT_STORAGE_OPTIONS,
+        ...options,
+    });
+    if (auraStorage === null) {
+        return new InMemoryPrefetchStorage();
+    }
+    return new AuraPrefetchStorage(auraStorage);
+}
+class AuraPrefetchStorage {
+    constructor(auraStorage) {
+        this.auraStorage = auraStorage;
+    }
+    set(key, value) {
+        return this.auraStorage.set(key, value);
+    }
+    async get(key) {
+        const result = await this.auraStorage.get(key);
+        return result ? result : undefined;
+    }
+}
 
 /**
  * Observability / Critical Availability Program (230+)
@@ -32,8 +720,8 @@ import { clearStorages } from 'force/ldsStorage';
  *
  * Below are the R.E.A.D.S. metrics for the Lightning Data Service, defined here[2].
  *
- * [1] https://salesforce.quip.com/NfW9AsbGEaTY
- * [2] https://salesforce.quip.com/1dFvAba1b0eq
+ * [1] Search "[M1] Lightning Data Service Design Spike" in Quip
+ * [2] Search "Lightning Data Service R.E.A.D.S. Metrics" in Quip
  */
 const OBSERVABILITY_NAMESPACE = 'LIGHTNING.lds.service';
 const ADAPTER_INVOCATION_COUNT_METRIC_NAME = 'request';
@@ -750,6 +1438,42 @@ function setupQueryEvaluators(luvio, store) {
     luvio.registerStoreQueryEvaluator(baseQueryEvaluator);
     luvio.registerTypeQueryEvaluator(UiApiNamespace, RecordRepresentationRepresentationType, recordRepresentationQueryEvaluator);
 }
+let __lexPrefetcher;
+function setupPredictivePrefetcher(luvio) {
+    const storage = buildAuraPrefetchStorage();
+    const repository = new PrefetchRepository(storage);
+    const requestRunner = new LexRequestRunner(luvio);
+    const prefetcher = new LexPredictivePrefetcher({ context: 'unknown' }, repository, requestRunner, {
+        getRecord: new GetRecordRequestStrategy(),
+        getRecords: new GetRecordsRequestStrategy(),
+        getRecordActions: new GetRecordActionsRequestStrategy(),
+        getRecordAvatars: new GetRecordAvatarsRequestStrategy(),
+    });
+    registerPrefetcher(luvio, prefetcher);
+    __lexPrefetcher = prefetcher;
+}
+// Triggers a payload.
+async function predictiveLoadPage(preloadProps) {
+    // the gate is disabled and the prefetcher was not setup.
+    if (__lexPrefetcher === undefined) {
+        return;
+    }
+    // This chunk configures which page we're going to use to try and preload.
+    const { objectApiName } = preloadProps.context;
+    const { recordId, actionName } = preloadProps.pageReference.attributes;
+    __lexPrefetcher.context = {
+        objectApiName,
+        recordId,
+        actionName,
+        type: 'recordPage',
+    };
+    // This chunk tells the prefetcher to receive events, send off any predictions we have from previous loads, then setup idle detection to stop predicting.
+    __lexPrefetcher.startRecording();
+    __lexPrefetcher.predict();
+    onIdleDetected(() => {
+        __lexPrefetcher.stopRecording();
+    });
+}
 // LDS initialization logic, invoked directly by Aura component tests
 function initializeLDS() {
     const storeOptions = {
@@ -765,6 +1489,9 @@ function initializeLDS() {
     setupQueryEvaluators(luvio, store);
     setDefaultLuvio({ luvio });
     setTrackedFieldsConfig(ldsTrackedFieldsBehaviorGate.isOpen({ fallback: false }));
+    if (usePredictiveLoading.isOpen({ fallback: false })) {
+        setupPredictivePrefetcher(luvio);
+    }
 }
 // service function to be invoked by Aura
 function ldsEngineCreator() {
@@ -772,5 +1499,5 @@ function ldsEngineCreator() {
     return { name: 'ldsEngineCreator' };
 }
 
-export { ldsEngineCreator as default, initializeLDS };
-// version: 1.245.0-0ea124370
+export { ldsEngineCreator as default, initializeLDS, predictiveLoadPage };
+// version: 1.247.0-4fe38c091

package/dist/types/aura-instrumentation/main.d.ts

@@ -2,6 +2,8 @@ import type { FetchResponse, Luvio, InMemoryStore, Adapter, UnfulfilledSnapshot
 import type { AdapterMetadata } from '@salesforce/lds-bindings';
 import { ADAPTER_UNFULFILLED_ERROR } from '@salesforce/lds-bindings';
 import type { CacheStatsLogger, Timer } from 'instrumentation/service';
+import { onIdleDetected } from '@salesforce/lds-instrumentation';
+export { onIdleDetected };
 export interface AdapterUnfulfilledError {
     [ADAPTER_UNFULFILLED_ERROR]: boolean;
     adapterName: string;
@@ -176,4 +178,3 @@ export declare function setupInstrumentation(luvio: Luvio, store: InMemoryStore)
  */
 export declare function logCRUDLightningInteraction(eventSource: string, attributes: object): void;
 export declare const instrumentation: Instrumentation;
-export {};

package/dist/types/aura-instrumentation/utils/observability.d.ts

@@ -6,8 +6,8 @@
  *
  * Below are the R.E.A.D.S. metrics for the Lightning Data Service, defined here[2].
  *
- * [1] https://salesforce.quip.com/NfW9AsbGEaTY
- * [2] https://salesforce.quip.com/1dFvAba1b0eq
+ * [1] Search "[M1] Lightning Data Service Design Spike" in Quip
+ * [2] Search "Lightning Data Service R.E.A.D.S. Metrics" in Quip
  */
 import type { MetricsKey } from 'instrumentation/service';
 export declare const OBSERVABILITY_NAMESPACE = "LIGHTNING.lds.service";

package/dist/types/main.d.ts

@@ -1,3 +1,19 @@
+type PreloadProps = {
+    context: {
+        objectApiName: string;
+    };
+    pageReference: LexPageReference;
+};
+type LexPageReference = {
+    attributes: {
+        actionName: string;
+        objectApiName: string;
+        recordId: string;
+    };
+    state: any;
+    type: string;
+};
+export declare function predictiveLoadPage(preloadProps: PreloadProps): Promise<void>;
 export declare function initializeLDS(): void;
 declare function ldsEngineCreator(): {
     name: string;

package/dist/types/predictive-loading/index.d.ts

@@ -0,0 +1,6 @@
+export * from './pages';
+export * from './prefetcher';
+export * from './repository';
+export * from './request-runner';
+export * from './request-strategy';
+export * from './storage';

package/dist/types/predictive-loading/pages/index.d.ts

@@ -0,0 +1,3 @@
+export * from './predictive-prefetch-page';
+export * from './lex-default-page';
+export * from './record-home-page';

package/dist/types/predictive-loading/pages/lex-default-page.d.ts

@@ -0,0 +1,12 @@
+import type { LexRequest } from '../prefetcher';
+import { PredictivePrefetchPage } from './predictive-prefetch-page';
+export type DefaultPageContext = Record<string, any>;
+export declare class LexDefaultPage extends PredictivePrefetchPage<LexRequest, DefaultPageContext> {
+    constructor(context: DefaultPageContext);
+    buildSaveRequestData(request: LexRequest): {
+        context: DefaultPageContext;
+        request: import("./record-home-page").RecordHomePageRequest;
+    };
+    resolveSimilarRequest(similarRequest: LexRequest): LexRequest;
+    getAlwaysRunRequests(): LexRequest[];
+}

package/dist/types/predictive-loading/pages/predictive-prefetch-page.d.ts

@@ -0,0 +1,11 @@
+export declare abstract class PredictivePrefetchPage<Request, Context> {
+    context: Context;
+    similarContext: Partial<Context> | undefined;
+    constructor(context: Context);
+    abstract buildSaveRequestData(request: Request): {
+        context: Context;
+        request: Request;
+    };
+    abstract resolveSimilarRequest(similarRequest: Request): Request;
+    abstract getAlwaysRunRequests(): Request[];
+}

package/dist/types/predictive-loading/pages/record-home-page.d.ts

@@ -0,0 +1,46 @@
+import type { LexContext } from '../prefetcher';
+import type { GetRecordRequest, GetRecordsRequest, GetRecordRequestStrategy, GetRecordsRequestStrategy, GetRecordActionsRequestStrategy, GetRecordActionsRequest, GetRecordAvatarsRequest, GetRecordAvatarsRequestStrategy } from '../request-strategy';
+import { PredictivePrefetchPage } from './predictive-prefetch-page';
+export type RecordHomePageContext = {
+    objectApiName: string;
+    recordId: string;
+    actionName: string;
+    type: 'recordPage';
+};
+export type RecordHomePageRequest = GetRecordRequest | GetRecordsRequest | GetRecordActionsRequest | GetRecordAvatarsRequest;
+export declare class RecordHomePage extends PredictivePrefetchPage<RecordHomePageRequest, RecordHomePageContext> {
+    private requestStrategies;
+    similarContext: RecordHomePageContext;
+    constructor(context: RecordHomePageContext, requestStrategies: {
+        getRecord: GetRecordRequestStrategy;
+        getRecords: GetRecordsRequestStrategy;
+        getRecordActions: GetRecordActionsRequestStrategy;
+        getRecordAvatars: GetRecordAvatarsRequestStrategy;
+    });
+    buildSaveRequestData(request: RecordHomePageRequest): {
+        request: GetRecordRequest;
+        context: RecordHomePageContext;
+    } | {
+        request: GetRecordsRequest;
+        context: RecordHomePageContext;
+    } | {
+        request: GetRecordActionsRequest;
+        context: RecordHomePageContext;
+    } | {
+        request: GetRecordAvatarsRequest;
+        context: RecordHomePageContext;
+    };
+    buildGetRecordSaveRequestData(request: GetRecordRequest): {
+        request: GetRecordRequest;
+        context: RecordHomePageContext;
+    };
+    buildGetRecordsSaveRequestData(request: GetRecordsRequest): {
+        request: GetRecordsRequest;
+        context: RecordHomePageContext;
+    };
+    isGetRecordRequestContextDependent(request: GetRecordRequest): boolean;
+    isGetRecordsRequestContextDependent(request: GetRecordsRequest): boolean;
+    resolveSimilarRequest(similarRequest: RecordHomePageRequest): RecordHomePageRequest;
+    getAlwaysRunRequests(): RecordHomePageRequest[];
+    static handlesContext(context: LexContext): context is RecordHomePageContext;
+}

package/dist/types/predictive-loading/prefetcher/index.d.ts

@@ -0,0 +1,2 @@
+export * from './predictive-prefetcher';
+export * from './lex-predictive-prefetcher';

package/dist/types/predictive-loading/prefetcher/lex-predictive-prefetcher.d.ts

@@ -0,0 +1,18 @@
+import type { DefaultPageContext, PredictivePrefetchPage } from '../pages';
+import { ApplicationPredictivePrefetcher } from './predictive-prefetcher';
+import type { GetRecordActionsRequestStrategy, GetRecordAvatarsRequestStrategy, GetRecordRequestStrategy, GetRecordsRequestStrategy } from '../request-strategy';
+import type { RequestRunner } from '../request-runner';
+import type { PrefetchRepository } from '../repository/prefetch-repository';
+import type { RecordHomePageContext, RecordHomePageRequest } from '../pages/record-home-page';
+export type LexRequest = RecordHomePageRequest;
+export type LexContext = RecordHomePageContext | DefaultPageContext;
+export declare class LexPredictivePrefetcher extends ApplicationPredictivePrefetcher<LexRequest, LexContext> {
+    private requestStrategies;
+    constructor(context: LexContext, repository: PrefetchRepository, requestRunner: RequestRunner<LexRequest>, requestStrategies: {
+        getRecord: GetRecordRequestStrategy;
+        getRecords: GetRecordsRequestStrategy;
+        getRecordActions: GetRecordActionsRequestStrategy;
+        getRecordAvatars: GetRecordAvatarsRequestStrategy;
+    });
+    getPage(): PredictivePrefetchPage<LexRequest, LexContext>;
+}

package/dist/types/predictive-loading/prefetcher/predictive-prefetcher.d.ts

@@ -0,0 +1,20 @@
+import type { PrefetchRepository } from '../repository/prefetch-repository';
+import type { PredictivePrefetchPage } from '../pages';
+import type { RequestRunner } from '../request-runner';
+export declare abstract class ApplicationPredictivePrefetcher<Request, Context extends Record<string, any>> {
+    private repository;
+    private requestRunner;
+    private _context;
+    isRecording: boolean;
+    page: PredictivePrefetchPage<Request, Context>;
+    queuedPredictionRequests: Request[];
+    constructor(context: Context, repository: PrefetchRepository, requestRunner: RequestRunner<Request>);
+    abstract getPage(): PredictivePrefetchPage<Request, Context>;
+    set context(value: Context);
+    get context(): Context;
+    stopRecording(): Promise<void>;
+    startRecording(): void;
+    saveRequest(request: Request): Promise<void>;
+    predict(): Promise<void>;
+    getSimilarPageRequests(): Promise<Request[]>;
+}

package/dist/types/predictive-loading/repository/index.d.ts

@@ -0,0 +1,2 @@
+export * from './prefetch-repository';
+export * from './utils';

package/dist/types/predictive-loading/repository/prefetch-repository.d.ts

@@ -0,0 +1,27 @@
+import type { PrefetchStorage } from '../storage';
+type Key = Record<string, any>;
+export type History = {
+    version: '1.0';
+    pages: Key[];
+};
+export type PageEntry<Request> = {
+    id: string;
+    requests: RequestEntry<Request>[];
+};
+export type RequestEntry<Request> = {
+    request: Request;
+    requestMetadata: {
+        requestTimes: number[];
+    };
+};
+export declare class PrefetchRepository {
+    private storage;
+    private requestBuffer;
+    constructor(storage: PrefetchStorage);
+    clearRequestBuffer(): void;
+    flushRequestsToStorage(): Promise<void>;
+    saveRequest<Request>(key: Key, request: Request): Promise<void>;
+    getPage<Request>(key: Key): Promise<PageEntry<Request> | undefined>;
+    getPageRequests<Request>(key: Key): Promise<Request[]>;
+}
+export {};

package/dist/types/predictive-loading/repository/utils.d.ts

@@ -0,0 +1,15 @@
+export declare const ObjectPrototypeHasOwnProperty: (v: PropertyKey) => boolean;
+export declare const ArrayIsArray: (arg: any) => arg is any[];
+/**
+ * A deterministic JSON stringify implementation. Heavily adapted from https://github.com/epoberezkin/fast-json-stable-stringify.
+ * This is needed because insertion order for JSON.stringify(object) affects output:
+ * JSON.stringify({a: 1, b: 2})
+ *      "{"a":1,"b":2}"
+ * JSON.stringify({b: 2, a: 1})
+ *      "{"b":2,"a":1}"
+ * @param data Data to be JSON-stringified.
+ * @returns JSON.stringified value with consistent ordering of keys.
+ */
+export declare function stableJSONStringify(node: any): string | undefined;
+export declare function isObject(obj: any): obj is Record<string, unknown>;
+export declare function deepEquals(objA: any, objB: any): boolean;

package/dist/types/predictive-loading/request-runner/index.d.ts

@@ -0,0 +1,2 @@
+export * from './request-runner';
+export * from './lex-request-runner';

package/dist/types/predictive-loading/request-runner/lex-request-runner.d.ts

@@ -0,0 +1,10 @@
+import type { Luvio } from '@luvio/engine';
+import type { LexRequest } from '../prefetcher';
+import type { RequestRunner } from './request-runner';
+export declare class LexRequestRunner implements RequestRunner<LexRequest> {
+    private luvio;
+    private requestStrategies;
+    constructor(luvio: Luvio);
+    reduceRequests(requests: LexRequest[]): LexRequest[];
+    runRequest(request: LexRequest): Promise<void>;
+}

package/dist/types/predictive-loading/request-runner/request-runner.d.ts

@@ -0,0 +1,4 @@
+export type RequestRunner<Request> = {
+    runRequest(request: Request): Promise<void>;
+    reduceRequests(requests: Request[]): Request[];
+};

package/dist/types/predictive-loading/request-strategy/get-record-actions-request-strategy.d.ts

@@ -0,0 +1,22 @@
+import type { GetRecordActionsConfig } from '@salesforce/lds-adapters-uiapi';
+import { LuvioAdapterRequestStrategy } from './luvio-adapter-request-strategy';
+import type { LuvioAdapterRequest } from './luvio-adapter-request';
+export type GetRecordActionsRequest = {
+    adapterName: 'getRecordActions';
+    config: GetRecordActionsConfig;
+};
+type GetRecordActionsContext = {
+    recordId: string;
+};
+export declare class GetRecordActionsRequestStrategy extends LuvioAdapterRequestStrategy<GetRecordActionsConfig, GetRecordActionsRequest, GetRecordActionsContext> {
+    adapterName: string;
+    adapterFactory: import("@luvio/engine").AdapterFactory<GetRecordActionsConfig, import("packages/lds-adapters-uiapi/dist/es/es2018/types/src/generated/types/ActionRepresentation").ActionRepresentation>;
+    buildConcreteRequest(similarRequest: GetRecordActionsRequest, context: GetRecordActionsContext): GetRecordActionsRequest;
+    buildGetRecordActionsSaveRequestData<C extends GetRecordActionsContext>(similarContext: C, context: C, request: GetRecordActionsRequest): {
+        request: GetRecordActionsRequest;
+        context: C;
+    };
+    private isGetRecordActionsRequestContextDependent;
+    reduce(unfilteredRequests: LuvioAdapterRequest<unknown>[]): GetRecordActionsRequest[];
+}
+export {};

package/dist/types/predictive-loading/request-strategy/get-record-avatars-request-strategy.d.ts

@@ -0,0 +1,22 @@
+import type { GetRecordAvatarsConfig } from '@salesforce/lds-adapters-uiapi';
+import { LuvioAdapterRequestStrategy } from './luvio-adapter-request-strategy';
+import type { LuvioAdapterRequest } from './luvio-adapter-request';
+export type GetRecordAvatarsRequest = {
+    adapterName: 'getRecordAvatars';
+    config: GetRecordAvatarsConfig;
+};
+type GetRecordAvatarsContext = {
+    recordId: string;
+};
+export declare class GetRecordAvatarsRequestStrategy extends LuvioAdapterRequestStrategy<GetRecordAvatarsConfig, GetRecordAvatarsRequest, GetRecordAvatarsContext> {
+    adapterName: string;
+    adapterFactory: import("@luvio/engine").AdapterFactory<GetRecordAvatarsConfig, import("packages/lds-adapters-uiapi/dist/es/es2018/types/src/generated/types/RecordAvatarBulkMapRepresentation").RecordAvatarBulkMapRepresentation>;
+    buildConcreteRequest(similarRequest: GetRecordAvatarsRequest, context: GetRecordAvatarsContext): GetRecordAvatarsRequest;
+    buildGetRecordAvatarsSaveRequestData<C extends GetRecordAvatarsContext>(similarContext: C, context: C, request: GetRecordAvatarsRequest): {
+        request: GetRecordAvatarsRequest;
+        context: C;
+    };
+    private isGetRecordAvatarsRequestContextDependent;
+    reduce(unfilteredRequests: LuvioAdapterRequest<unknown>[]): GetRecordAvatarsRequest[];
+}
+export {};

package/dist/types/predictive-loading/request-strategy/get-record-request-strategy.d.ts

@@ -0,0 +1,18 @@
+import type { GetRecordConfig } from '@salesforce/lds-adapters-uiapi';
+import { LuvioAdapterRequestStrategy } from './luvio-adapter-request-strategy';
+export type GetRecordRequest = {
+    adapterName: 'getRecord';
+    config: GetRecordConfig;
+};
+import type { LuvioAdapterRequest } from './luvio-adapter-request';
+type GetRecordContext = {
+    recordId: string;
+};
+export declare class GetRecordRequestStrategy extends LuvioAdapterRequestStrategy<GetRecordConfig, GetRecordRequest, GetRecordContext> {
+    adapterName: string;
+    adapterFactory: import("@luvio/engine").AdapterFactory<GetRecordConfig, import("@salesforce/lds-adapters-uiapi").RecordRepresentation>;
+    buildConcreteRequest(similarRequest: GetRecordRequest, context: GetRecordContext): GetRecordRequest;
+    transformForSave(request: GetRecordRequest): GetRecordRequest;
+    reduce(unfilteredRequests: LuvioAdapterRequest<unknown>[]): GetRecordRequest[];
+}
+export {};

package/dist/types/predictive-loading/request-strategy/get-records-request-strategy.d.ts

@@ -0,0 +1,15 @@
+import type { GetRecordsConfig } from '@salesforce/lds-adapters-uiapi';
+import { LuvioAdapterRequestStrategy } from './luvio-adapter-request-strategy';
+export type GetRecordsRequest = {
+    adapterName: 'getRecords';
+    config: GetRecordsConfig;
+};
+type GetRecordsContext = {
+    recordId: string;
+};
+export declare class GetRecordsRequestStrategy extends LuvioAdapterRequestStrategy<GetRecordsConfig, GetRecordsRequest, GetRecordsContext> {
+    adapterName: string;
+    adapterFactory: import("@luvio/engine").AdapterFactory<GetRecordsConfig, import("@salesforce/lds-adapters-uiapi").BatchRepresentation>;
+    buildConcreteRequest(similarRequest: GetRecordsRequest, context: GetRecordsContext): GetRecordsRequest;
+}
+export {};

package/dist/types/predictive-loading/request-strategy/index.d.ts

@@ -0,0 +1,7 @@
+export * from './get-record-avatars-request-strategy';
+export * from './get-record-request-strategy';
+export * from './get-records-request-strategy';
+export * from './get-record-actions-request-strategy';
+export * from './luvio-adapter-request-strategy';
+export * from './luvio-adapter-request';
+export * from './request-strategy';

package/dist/types/predictive-loading/request-strategy/luvio-adapter-request-strategy.d.ts

@@ -0,0 +1,10 @@
+import type { AdapterFactory } from '@luvio/engine';
+import { RequestStrategy } from './request-strategy';
+import type { LuvioAdapterRequest } from './luvio-adapter-request';
+export declare abstract class LuvioAdapterRequestStrategy<AdapterConfig, Request extends LuvioAdapterRequest<AdapterConfig>, Context> extends RequestStrategy<Request, Context> {
+    abstract adapterName: string;
+    abstract adapterFactory: AdapterFactory<AdapterConfig, any>;
+    transformForSave(request: Request): Request;
+    protected filterRequests(unfilteredRequests: LuvioAdapterRequest<unknown>[]): Request[];
+    reduce(unfilteredRequests: LuvioAdapterRequest<unknown>[]): Request[];
+}

package/dist/types/predictive-loading/request-strategy/luvio-adapter-request.d.ts

@@ -0,0 +1,4 @@
+export type LuvioAdapterRequest<Config> = {
+    adapterName: string;
+    config: Config;
+};

package/dist/types/predictive-loading/request-strategy/request-strategy.d.ts

@@ -0,0 +1,5 @@
+export declare abstract class RequestStrategy<Request, Context> {
+    abstract buildConcreteRequest(similarRequest: Request, context: Context): Request;
+    transformForSave(request: Request): Request;
+    reduce(requests: Request[]): Request[];
+}

package/dist/types/predictive-loading/storage/aura-prefetch-storage.d.ts

@@ -0,0 +1,18 @@
+import { type PrefetchStorage } from '.';
+import { type AuraStorage, type AuraStorageConfig } from '@salesforce/lds-aura-storage';
+export declare const DEFAULT_STORAGE_OPTIONS: {
+    name: string;
+    persistent: boolean;
+    secure: boolean;
+    maxSize: number;
+    expiration: number;
+    clearOnInit: boolean;
+    debugLogging: boolean;
+};
+export declare function buildAuraPrefetchStorage(options?: Partial<AuraStorageConfig>): PrefetchStorage;
+export declare class AuraPrefetchStorage implements PrefetchStorage {
+    private auraStorage;
+    constructor(auraStorage: AuraStorage);
+    set<T>(key: string, value: T): Promise<void>;
+    get<T>(key: string): Promise<T | undefined>;
+}

package/dist/types/predictive-loading/storage/in-memory-prefetch-storage.d.ts

@@ -0,0 +1,6 @@
+import type { PrefetchStorage } from '.';
+export declare class InMemoryPrefetchStorage implements PrefetchStorage {
+    data: Record<string, any>;
+    set<T>(key: string, value: T): Promise<void>;
+    get<T>(key: string): Promise<T | undefined>;
+}

package/dist/types/predictive-loading/storage/index.d.ts

@@ -0,0 +1,7 @@
+export type PrefetchStorage = {
+    get<T>(key: string): Promise<T | undefined>;
+    set<T>(key: string, value: T): Promise<void>;
+};
+export * from './in-memory-prefetch-storage';
+export * from './local-prefetch-storage';
+export { buildAuraPrefetchStorage } from './aura-prefetch-storage';

package/dist/types/predictive-loading/storage/local-prefetch-storage.d.ts

@@ -0,0 +1,7 @@
+import type { PrefetchStorage } from '.';
+export declare class LocalPrefetchStorage implements PrefetchStorage {
+    private localStorage;
+    constructor(localStorage: typeof window.localStorage);
+    set<T>(key: string, value: T): Promise<void>;
+    get<T>(key: string): Promise<T | undefined>;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@salesforce/lds-runtime-aura",
-    "version": "1.245.0",
+    "version": "1.247.0",
     "license": "SEE LICENSE IN LICENSE.txt",
     "description": "LDS engine for Aura runtime",
     "main": "dist/ldsEngineCreator.js",
@@ -43,16 +43,19 @@
         "@salesforce/lds-network-fetch-with-jwt": "*"
     },
     "dependencies": {
-        "@luvio/network-adapter-composable": "0.150.5"
+        "@luvio/network-adapter-composable": "0.151.0"
     },
     "luvioBundlesize": [
         {
             "path": "./dist/ldsEngineCreator.js",
             "maxSize": {
-                "none": "32 kB",
-                "min": "13 kB",
-                "compressed": "8 kB"
+                "none": "60 kB",
+                "min": "28 kB",
+                "compressed": "12 kB"
             }
         }
-    ]
+    ],
+    "volta": {
+        "extends": "../../package.json"
+    }
 }