@salesforce/lds-runtime-aura 1.410.1 → 1.411.0

package/dist/ldsEngineCreator.js

@@ -18,7 +18,6 @@ import usePredictiveLoading from '@salesforce/gate/lds.usePredictiveLoading';
 import useApexPredictions from '@salesforce/gate/lds.pdl.useApexPredictions';
 import useRelatedListsPredictions from '@salesforce/gate/lds.pdl.useRelatedListsPredictions';
 import useRelatedListPlus from '@salesforce/gate/lds.pdl.useRelatedListPlus';
-import useCmpDefPredictions from '@salesforce/gate/lds.pdl.useCmpDefPredictions';
 import applyPredictionRequestLimit from '@salesforce/gate/lds.pdl.applyRequestLimit';
 import useLocalStorage from '@salesforce/gate/lds.pdl.useLocalStorage';
 import useOneStoreGraphql from '@salesforce/gate/lds.oneStoreGraphqlEnabled.ltng';
@@ -2703,7 +2702,7 @@ function buildServiceDescriptor$d(luvio) {
         },
     };
 }
-// version: 1.410.1-ee98040f21
+// version: 1.411.0-8fa163ef05
 
 /*!
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -3056,7 +3055,7 @@ function buildServiceDescriptor$9(notifyRecordUpdateAvailable, getNormalizedLuvi
         },
     };
 }
-// version: 1.410.1-ee98040f21
+// version: 1.411.0-8fa163ef05
 
 /*!
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -4806,7 +4805,7 @@ function getEnvironmentSetting(name) {
     }
     return undefined;
 }
-// version: 1.410.1-ee98040f21
+// version: 1.411.0-8fa163ef05
 
 /**
  * Observability / Critical Availability Program (230+)
@@ -8127,10 +8126,45 @@ class ObjectHomePage extends AbstractHomePage {
     }
 }
 
+var PdlPrefetcherEventType;
+(function (PdlPrefetcherEventType) {
+    PdlPrefetcherEventType["STARTED_RECORDING"] = "started-recording";
+    PdlPrefetcherEventType["STOPPED_RECORDING"] = "stopped-recording";
+})(PdlPrefetcherEventType || (PdlPrefetcherEventType = {}));
+class PrefetcherEventEmitter {
+    constructor() {
+        this.listeners = new Map();
+    }
+    subscribeTo(type, listener) {
+        const typeListeners = this.listeners.get(type) ?? [];
+        typeListeners.push(listener);
+        this.listeners.set(type, typeListeners);
+        return () => {
+            const currentListeners = this.listeners.get(type) ?? [];
+            this.listeners.set(type, currentListeners.filter((l) => l !== listener));
+        };
+    }
+    emit(event) {
+        const typeListeners = this.listeners.get(event.type) ?? [];
+        typeListeners.forEach((listener) => {
+            try {
+                listener(event);
+            }
+            catch (error) {
+                // swallow errors in production.
+                if (process.env.NODE_ENV !== 'production') {
+                    throw error;
+                }
+            }
+        });
+    }
+}
+
 class ApplicationPredictivePrefetcher {
-    constructor(context, repository, requestRunner) {
+    constructor(context, repository, requestRunner, eventEmitter) {
         this.repository = repository;
         this.requestRunner = requestRunner;
+        this.eventEmitter = eventEmitter;
         this.isRecording = false;
         this.totalRequestCount = 0;
         this.queuedPredictionRequests = [];
@@ -8144,15 +8178,26 @@ class ApplicationPredictivePrefetcher {
     get context() {
         return this._context;
     }
+    subscribeToEvent(type, callback) {
+        return this.eventEmitter.subscribeTo(type, callback);
+    }
     async stopRecording() {
         this.isRecording = false;
         this.totalRequestCount = 0;
         await this.repository.flushRequestsToStorage();
+        this.eventEmitter.emit({
+            type: PdlPrefetcherEventType.STOPPED_RECORDING,
+            page: this.page,
+        });
     }
     startRecording() {
         this.isRecording = true;
         this.repository.markPageStart();
         this.repository.clearRequestBuffer();
+        this.eventEmitter.emit({
+            type: PdlPrefetcherEventType.STARTED_RECORDING,
+            page: this.page,
+        });
     }
     saveRequest(request) {
         if (!this.isRecording) {
@@ -8335,11 +8380,11 @@ function predictNonBoxcarableRequest(nonBoxcaredPredictions, requestRunner) {
 const DEFAULT_RECORD_TYPE_ID = '012000000000000AAA';
 const AURA_BOXCAR_THREADS_THRESHOLD = 3;
 class LexPredictivePrefetcher extends ApplicationPredictivePrefetcher {
-    constructor(context, repository, requestRunner, 
+    constructor(context, repository, requestRunner, eventEmitter, 
     // These strategies need to be in sync with the "predictiveDataLoadCapable" list
     // from scripts/lds-uiapi-plugin.js
     requestStrategyManager, options) {
-        super(context, repository, requestRunner);
+        super(context, repository, requestRunner, eventEmitter);
         this.options = options;
         this.requestStrategyManager = requestStrategyManager;
         this.page = this.getPage();
@@ -9744,43 +9789,31 @@ function setupPredictivePrefetcher(luvio) {
     const prefetcherOptions = {
         inflightRequestLimit,
     };
-    const prefetcher = new LexPredictivePrefetcher({ context: 'unknown' }, repository, requestRunner, requestStrategyManager, prefetcherOptions);
+    const eventEmitter = new PrefetcherEventEmitter();
+    const prefetcher = new LexPredictivePrefetcher({ context: 'unknown' }, repository, requestRunner, eventEmitter, requestStrategyManager, prefetcherOptions);
     registerPrefetcher(luvio, prefetcher);
     if (useApexPredictions.isOpen({ fallback: false })) {
         registerPrefetcher$1(luvio, prefetcher);
     }
     __lexPrefetcher = prefetcher;
 }
-function loadComponentsDefStartedOverride(...args) {
-    /**
-     * To install an override (taken from the Aura.Utils.Override):
-     *
-     * The function supplied should have the following code in it:
-     * ------
-     *  var config = Array.prototype.shift.apply(arguments);
-     *  var ret = config["fn"].apply(config["scope"], arguments);
-     *  return ret
-     * ------
-     */
-    const config = Array.prototype.shift.apply(args);
-    const ret = config['fn'].apply(config['scope'], args);
-    try {
-        const defs = args[0] || {};
-        __lexPrefetcher.saveRequest({
-            adapterName: 'getComponentsDef',
-            config: defs,
-        });
-    }
-    catch (e) {
-        // dismiss any error, the activity will log it.
-    }
-    return ret;
-}
 function saveRequestAsPrediction(request) {
     if (__lexPrefetcher !== undefined) {
         __lexPrefetcher.saveRequest(request);
     }
 }
+/**
+ * Subscribes to a specific prefetcher event type.
+ * @param type - The type of event to subscribe to.
+ * @param callback - The callback to invoke when the specified event occurs.
+ * @returns A function to unsubscribe from the prefetcher events.
+ */
+function subscribeToPrefetcherEvents(type, callback) {
+    if (__lexPrefetcher !== undefined) {
+        return __lexPrefetcher.subscribeToEvent(type, callback);
+    }
+    return () => { };
+}
 // This is copied from lds-adapters-uiapi because the exports are totally messed up
 const notifyUpdateAvailableFactory = (luvio) => {
     return function notifyRecordUpdateAvailable(configs) {
@@ -9849,23 +9882,7 @@ function buildPredictorForContext(context) {
         watchPageLoadForPredictions() {
             // 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();
-            // We only want to use cmpDef predictions on PROD code,
-            // as in dev, it is assumed that the definitions will change often
-            if (process.env.NODE_ENV === 'production') {
-                if (useCmpDefPredictions.isOpen({ fallback: false })) {
-                    window['$A'].installOverride('ComponentService.loadComponentDefsStarted', loadComponentsDefStartedOverride);
-                }
-            }
-            onIdleDetected(() => {
-                __lexPrefetcher.stopRecording();
-                // We only want to use cmpDef predictions on PROD code,
-                // as in dev, it is assumed that the definitions will change often
-                if (process.env.NODE_ENV === 'production') {
-                    if (useCmpDefPredictions.isOpen({ fallback: false })) {
-                        window['$A'].uninstallOverride('ComponentService.loadComponentDefsStarted', loadComponentsDefStartedOverride);
-                    }
-                }
-            });
+            onIdleDetected(() => __lexPrefetcher.stopRecording());
         },
         runPredictions() {
             if (isSameContext) {
@@ -9997,5 +10014,5 @@ function ldsEngineCreator() {
     return { name: 'ldsEngineCreator' };
 }
 
-export { LexRequestStrategy, PdlRequestPriority, buildPredictorForContext, ldsEngineCreator as default, initializeLDS, initializeOneStore, notifyUpdateAvailableFactory, registerRequestStrategy, saveRequestAsPrediction, unregisterRequestStrategy, whenPredictionsReady };
-// version: 1.410.1-f2ce00a20c
+export { LexRequestStrategy, PdlPrefetcherEventType, PdlRequestPriority, buildPredictorForContext, ldsEngineCreator as default, initializeLDS, initializeOneStore, notifyUpdateAvailableFactory, registerRequestStrategy, saveRequestAsPrediction, subscribeToPrefetcherEvents, unregisterRequestStrategy, whenPredictionsReady };
+// version: 1.411.0-193e3a20c1

package/dist/types/main.d.ts

@@ -1,9 +1,9 @@
 import { Luvio } from '@luvio/engine';
 import { KeyParamsRecord } from '@salesforce/lds-adapters-uiapi';
-import { ObjectHomePageContext, type RecordHomePageContext } from './predictive-loading';
+import { ObjectHomePageContext, PdlPrefetcherEventType, PrefetcherEventMap, type RecordHomePageContext } from './predictive-loading';
 import type { LexRequestStrategy } from './predictive-loading/request-strategy/lex-request-strategy';
 import { type LexRequest } from './predictive-loading/lex';
-export { PdlRequestPriority } from './predictive-loading';
+export { PdlRequestPriority, PdlPrefetcherEventType } from './predictive-loading';
 export { LexRequestStrategy } from './predictive-loading/request-strategy/lex-request-strategy';
 /**
  * Registers a request strategy to be utilized by PDL.
@@ -19,6 +19,13 @@ export declare function registerRequestStrategy(...requestStrategy: LexRequestSt
 export declare function unregisterRequestStrategy(...requestStrategy: LexRequestStrategy[]): boolean | boolean[];
 export declare function whenPredictionsReady(callback: () => void): void;
 export declare function saveRequestAsPrediction(request: LexRequest): void;
+/**
+ * Subscribes to a specific prefetcher event type.
+ * @param type - The type of event to subscribe to.
+ * @param callback - The callback to invoke when the specified event occurs.
+ * @returns A function to unsubscribe from the prefetcher events.
+ */
+export declare function subscribeToPrefetcherEvents<T extends PdlPrefetcherEventType>(type: T, callback: (event: PrefetcherEventMap[T]) => void): () => void;
 export declare const notifyUpdateAvailableFactory: (luvio: Luvio) => (configs: Partial<KeyParamsRecord>[]) => Promise<void>;
 /**
  * @typedef {Object} RecordHomePageContext

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

@@ -0,0 +1,25 @@
+import type { PredictivePrefetchPage } from '../pages';
+export declare enum PdlPrefetcherEventType {
+    STARTED_RECORDING = "started-recording",
+    STOPPED_RECORDING = "stopped-recording"
+}
+export type StartedRecordingEvent = {
+    type: PdlPrefetcherEventType.STARTED_RECORDING;
+    page: PredictivePrefetchPage<any, any>;
+};
+export type StoppedRecordingEvent = {
+    type: PdlPrefetcherEventType.STOPPED_RECORDING;
+    page: PredictivePrefetchPage<any, any>;
+};
+export type PrefetcherEvent = StartedRecordingEvent | StoppedRecordingEvent;
+export type PrefetcherEventMap = {
+    [PdlPrefetcherEventType.STARTED_RECORDING]: StartedRecordingEvent;
+    [PdlPrefetcherEventType.STOPPED_RECORDING]: StoppedRecordingEvent;
+};
+type ListenerFn<T extends PdlPrefetcherEventType> = (event: PrefetcherEventMap[T]) => void;
+export declare class PrefetcherEventEmitter {
+    private listeners;
+    subscribeTo<T extends PdlPrefetcherEventType>(type: T, listener: ListenerFn<T>): () => void;
+    emit<T extends PdlPrefetcherEventType>(event: PrefetcherEventMap[T]): void;
+}
+export {};

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

@@ -1,2 +1,4 @@
 export * from './predictive-prefetcher';
 export * from './lex-predictive-prefetcher';
+export type { PrefetcherEvent, StartedRecordingEvent, StoppedRecordingEvent, PrefetcherEventMap, } from './events';
+export { PdlPrefetcherEventType } from './events';

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

@@ -5,11 +5,12 @@ import type { PrefetchRepository } from '../repository';
 import type { RequestEntry } from '../common';
 import type { LexContext, LexPrefetcherOptions, LexRequest } from '../lex';
 import type { RequestStrategyManager } from '../request-strategy-manager/request-strategy-manager';
+import { PrefetcherEventEmitter } from './events';
 export declare class LexPredictivePrefetcher extends ApplicationPredictivePrefetcher<LexRequest, LexContext, LexDefaultPage<LexRequest, LexContext>> {
     protected options: LexPrefetcherOptions;
     page: LexDefaultPage<LexRequest, LexContext>;
     private requestStrategyManager;
-    constructor(context: LexContext, repository: PrefetchRepository<LexRequest>, requestRunner: RequestRunner<LexRequest>, requestStrategyManager: RequestStrategyManager, options: LexPrefetcherOptions);
+    constructor(context: LexContext, repository: PrefetchRepository<LexRequest>, requestRunner: RequestRunner<LexRequest>, eventEmitter: PrefetcherEventEmitter, requestStrategyManager: RequestStrategyManager, options: LexPrefetcherOptions);
     getPage(): LexDefaultPage<LexRequest, LexContext>;
     getAllPageRequests(): RequestEntry<LexRequest>[];
     getPredictedRequestsOrderedByPriority(): RequestEntry<LexRequest>[];

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

@@ -2,18 +2,21 @@ import type { PrefetchRepository } from '../repository';
 import type { PredictivePrefetchPage } from '../pages';
 import type { RequestRunner } from '../request-runner';
 import type { BaseAdapterRequest } from '../request-strategy';
+import { PrefetcherEventEmitter, PdlPrefetcherEventType, PrefetcherEventMap } from './events';
 export declare abstract class ApplicationPredictivePrefetcher<Request extends BaseAdapterRequest, Context extends Record<string, any>, Page extends PredictivePrefetchPage<Request, Context>> {
     protected repository: PrefetchRepository<Request>;
     protected requestRunner: RequestRunner<Request>;
+    protected eventEmitter: PrefetcherEventEmitter;
     private _context;
     isRecording: boolean;
     totalRequestCount: Number;
     page: Page;
     queuedPredictionRequests: Request[];
-    protected constructor(context: Context, repository: PrefetchRepository<Request>, requestRunner: RequestRunner<Request>);
+    protected constructor(context: Context, repository: PrefetchRepository<Request>, requestRunner: RequestRunner<Request>, eventEmitter: PrefetcherEventEmitter);
     abstract getPage(): Page;
     set context(value: Context);
     get context(): Context;
+    subscribeToEvent<T extends PdlPrefetcherEventType>(type: T, callback: (event: PrefetcherEventMap[T]) => void): () => void;
     stopRecording(): Promise<void>;
     startRecording(): void;
     saveRequest(request: Request): void;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@salesforce/lds-runtime-aura",
-    "version": "1.410.1",
+    "version": "1.411.0",
     "license": "SEE LICENSE IN LICENSE.txt",
     "description": "LDS engine for Aura runtime",
     "main": "dist/ldsEngineCreator.js",
@@ -36,14 +36,14 @@
     "devDependencies": {
         "@conduit-client/service-provisioner": "3.6.3",
         "@conduit-client/tools-core": "3.6.3",
-        "@salesforce/lds-adapters-apex": "^1.410.1",
-        "@salesforce/lds-adapters-uiapi": "^1.410.1",
-        "@salesforce/lds-ads-bridge": "^1.410.1",
-        "@salesforce/lds-aura-storage": "^1.410.1",
-        "@salesforce/lds-bindings": "^1.410.1",
-        "@salesforce/lds-instrumentation": "^1.410.1",
-        "@salesforce/lds-network-aura": "^1.410.1",
-        "@salesforce/lds-network-fetch": "^1.410.1",
+        "@salesforce/lds-adapters-apex": "^1.411.0",
+        "@salesforce/lds-adapters-uiapi": "^1.411.0",
+        "@salesforce/lds-ads-bridge": "^1.411.0",
+        "@salesforce/lds-aura-storage": "^1.411.0",
+        "@salesforce/lds-bindings": "^1.411.0",
+        "@salesforce/lds-instrumentation": "^1.411.0",
+        "@salesforce/lds-network-aura": "^1.411.0",
+        "@salesforce/lds-network-fetch": "^1.411.0",
         "jwt-encode": "1.0.1"
     },
     "dependencies": {
@@ -73,10 +73,10 @@
         "@luvio/network-adapter-composable": "0.158.7",
         "@luvio/network-adapter-fetch": "0.158.7",
         "@lwc/state": "^0.23.0",
-        "@salesforce/lds-adapters-onestore-graphql": "^1.410.1",
-        "@salesforce/lds-adapters-uiapi-lex": "^1.410.1",
-        "@salesforce/lds-luvio-service": "^1.410.1",
-        "@salesforce/lds-luvio-uiapi-records-service": "^1.410.1"
+        "@salesforce/lds-adapters-onestore-graphql": "^1.411.0",
+        "@salesforce/lds-adapters-uiapi-lex": "^1.411.0",
+        "@salesforce/lds-luvio-service": "^1.411.0",
+        "@salesforce/lds-luvio-uiapi-records-service": "^1.411.0"
     },
     "luvioBundlesize": [
         {