@salesforce/lds-runtime-aura 1.244.0 → 1.246.0

package/dist/ldsEngineCreator.js

@@ -14,16 +14,430 @@
 /* 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 { getRecordAdapterFactory, getRecordsAdapterFactory, instrument, configuration, InMemoryRecordRepresentationQueryEvaluator, UiApiNamespace, RecordRepresentationRepresentationType, registerPrefetcher } from 'force/ldsAdaptersUiapi';
 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;
+    }
+}
+
+class RecordHomePage extends PredictivePrefetchPage {
+    constructor(context, requestStrategies) {
+        super(context);
+        this.requestStrategies = requestStrategies;
+        const { recordId: _, ...rest } = this.context;
+        this.similarContext = {
+            recordId: '*',
+            ...rest,
+        };
+    }
+    buildSaveRequestData(request) {
+        if (request.adapterName === 'getRecord') {
+            return this.buildGetRecordSaveRequestData(request);
+        }
+        else if (request.adapterName === 'getRecords') {
+            return this.buildGetRecordsSaveRequestData(request);
+        }
+        else {
+            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);
+        }
+        return similarRequest;
+    }
+    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;
+    }
+    stopRecording() {
+        this.isRecording = false;
+    }
+    startRecording() {
+        this.isRecording = true;
+    }
+    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.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 + '}';
+}
+
+class PrefetchRepository {
+    constructor(storage) {
+        this.storage = storage;
+    }
+    async saveRequest(key, request) {
+        const identifier = stableJSONStringify$1(key);
+        const rawPage = await this.storage.get(identifier);
+        const page = rawPage === undefined ? { identifier, requests: [] } : JSON.parse(rawPage);
+        const stringifiedRequest = stableJSONStringify$1(request);
+        let existingRequestEntry = page.requests.find((requestEntry) => stableJSONStringify$1(requestEntry.request) === stringifiedRequest);
+        if (existingRequestEntry === undefined) {
+            existingRequestEntry = { request, requestMetadata: { requestTimes: [] } };
+            page.requests.push(existingRequestEntry);
+        }
+        existingRequestEntry.requestMetadata.requestTimes.push(Date.now());
+        return this.storage.set(identifier, stableJSONStringify$1(page));
+    }
+    async getPage(key) {
+        const identifier = stableJSONStringify$1(key);
+        const rawPage = await this.storage.get(identifier);
+        if (rawPage === undefined) {
+            return;
+        }
+        return JSON.parse(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;
+    }
+    reduce(requests) {
+        return requests;
+    }
+}
+
+class GetRecordRequestStrategy extends LuvioAdapterRequestStrategy {
+    constructor() {
+        super(...arguments);
+        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;
+        }
+        return {
+            ...request,
+            config: {
+                ...request.config,
+                fields: undefined,
+                optionalFields: [
+                    ...(request.config.fields || []),
+                    ...(request.config.optionalFields || []),
+                ],
+            },
+        };
+    }
+    reduce(requests) {
+        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.adapterFactory = getRecordsAdapterFactory;
+    }
+    buildConcreteRequest(similarRequest, context) {
+        return {
+            ...similarRequest,
+            config: {
+                ...similarRequest.config,
+                records: [{ ...similarRequest.config.records[0], recordIds: [context.recordId] }],
+            },
+        };
+    }
+}
+
+class LexRequestRunner {
+    constructor(luvio) {
+        this.luvio = luvio;
+        this.requestStrategies = {
+            getRecord: new GetRecordRequestStrategy(),
+            getRecords: new GetRecordsRequestStrategy(),
+        };
+    }
+    reduceRequests(requests) {
+        const getRecordRequests = requests.filter((request) => request.adapterName === 'getRecord');
+        const otherRequests = requests.filter((request) => request.adapterName !== 'getRecord');
+        return [...this.requestStrategies.getRecord.reduce(getRecordRequests), ...otherRequests];
+    }
+    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 LocalPrefetchStorage {
+    constructor(localStorage) {
+        this.localStorage = localStorage;
+    }
+    set(key, value) {
+        this.localStorage.setItem(key, value);
+        return Promise.resolve();
+    }
+    get(key) {
+        return Promise.resolve(this.localStorage.getItem(key) || undefined);
+    }
+}
+
 /**
  * Observability / Critical Availability Program (230+)
  *
@@ -724,6 +1138,7 @@ function setupMetadataWatcher(luvio) {
     });
 }
 
+// import { createStorage } from '@salesforce/lds-aura-storage';
 // This code *should* be in lds-network-adapter, but when combined with the Aura
 // component test workaround in lds-default-luvio it creates a circular dependecy
 // between lds-default-luvio and lds-network-adapter. We do the register on behalf
@@ -750,6 +1165,40 @@ function setupQueryEvaluators(luvio, store) {
     luvio.registerStoreQueryEvaluator(baseQueryEvaluator);
     luvio.registerTypeQueryEvaluator(UiApiNamespace, RecordRepresentationRepresentationType, recordRepresentationQueryEvaluator);
 }
+let __lexPrefetcher;
+function setupPredictivePrefetcher(luvio) {
+    const storage = new LocalPrefetchStorage(window.localStorage);
+    const repository = new PrefetchRepository(storage);
+    const requestRunner = new LexRequestRunner(luvio);
+    const prefetcher = new LexPredictivePrefetcher({ context: 'unknown' }, repository, requestRunner, {
+        getRecord: new GetRecordRequestStrategy(),
+        getRecords: new GetRecordsRequestStrategy(),
+    });
+    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 +1214,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 +1224,5 @@ function ldsEngineCreator() {
     return { name: 'ldsEngineCreator' };
 }
 
-export { ldsEngineCreator as default, initializeLDS };
-// version: 1.244.0-72e322fff
+export { ldsEngineCreator as default, initializeLDS, predictiveLoadPage };
+// version: 1.246.0-8357100fc

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

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

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

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

@@ -0,0 +1,37 @@
+import type { LexContext } from '../prefetcher';
+import type { GetRecordRequest, GetRecordsRequest, GetRecordRequestStrategy, GetRecordsRequestStrategy } 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;
+export declare class RecordHomePage extends PredictivePrefetchPage<RecordHomePageRequest, RecordHomePageContext> {
+    private requestStrategies;
+    similarContext: RecordHomePageContext;
+    constructor(context: RecordHomePageContext, requestStrategies: {
+        getRecord: GetRecordRequestStrategy;
+        getRecords: GetRecordsRequestStrategy;
+    });
+    buildSaveRequestData(request: RecordHomePageRequest): {
+        request: GetRecordRequest;
+        context: RecordHomePageContext;
+    } | {
+        request: GetRecordsRequest;
+        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;
+    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,16 @@
+import type { DefaultPageContext, PredictivePrefetchPage } from '../pages';
+import { ApplicationPredictivePrefetcher } from './predictive-prefetcher';
+import type { 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;
+    });
+    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(): 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,24 @@
+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;
+    constructor(storage: PrefetchStorage);
+    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,13 @@
+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;

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-request-strategy.d.ts

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

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

@@ -0,0 +1,14 @@
+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> {
+    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,5 @@
+export * from './get-record-request-strategy';
+export * from './get-records-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,8 @@
+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 adapterFactory: AdapterFactory<AdapterConfig, any>;
+    transformForSave(request: Request): Request;
+    reduce(requests: Request[]): 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/in-memory-prefetch-storage.d.ts

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

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@salesforce/lds-runtime-aura",
-    "version": "1.244.0",
+    "version": "1.246.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.3"
+        "@luvio/network-adapter-composable": "0.150.6"
     },
     "luvioBundlesize": [
         {
             "path": "./dist/ldsEngineCreator.js",
             "maxSize": {
-                "none": "32 kB",
-                "min": "13 kB",
-                "compressed": "8 kB"
+                "none": "50 kB",
+                "min": "22 kB",
+                "compressed": "10 kB"
             }
         }
-    ]
+    ],
+    "volta": {
+        "extends": "../../package.json"
+    }
 }