@salesforce/lds-runtime-aura 1.328.0 → 1.329.0

package/dist/ldsEngineCreator.js

@@ -33,6 +33,7 @@ import { REFRESH_ADAPTER_EVENT, ADAPTER_UNFULFILLED_ERROR, instrument as instrum
 import { counter, registerCacheStats, perfStart, perfEnd, registerPeriodicLogger, interaction, timer } from 'instrumentation/service';
 import { instrument as instrument$4 } from 'force/adsBridge';
 import { withRegistration, register, setDefaultLuvio } from 'force/ldsEngine';
+import useHotspotLimit from '@salesforce/gate/lds.pdl.useHotspotLimit';
 import { createStorage, clearStorages } from 'force/ldsStorage';
 import useHttpInsteadAuraTransport from '@salesforce/gate/lds.useHttpInsteadAuraTransport';
 import { ThirdPartyTracker } from 'instrumentation:beaconLib';
@@ -2170,11 +2171,20 @@ class LuvioAdapterRequestStrategy extends LexRequestStrategy {
         super();
         this.luvio = luvio;
     }
-    execute(config, requestContext) {
-        return this.adapterFactory(this.luvio)(config, {
+    execute(config, options = {}) {
+        return this.adapterFactory(this.luvio)(config, this.createAdapterContext(options));
+    }
+    createAdapterContext(options) {
+        return {
             ...DEFAULT_RESOURCE_CONTEXT,
-            ...requestContext,
-        });
+            sourceContext: {
+                ...DEFAULT_RESOURCE_CONTEXT.sourceContext,
+                actionConfig: {
+                    ...DEFAULT_RESOURCE_CONTEXT.sourceContext.actionConfig,
+                    hotspot: !options.disableHotspot,
+                },
+            },
+        };
     }
 }
 
@@ -3020,8 +3030,11 @@ class GetApexRequestStrategy extends LuvioAdapterRequestStrategy {
     buildConcreteRequest(similarRequest) {
         return similarRequest;
     }
-    execute(config, _requestContext) {
-        return super.execute(config, APEX_RESOURCE_CONTEXT);
+    createAdapterContext(_options) {
+        return APEX_RESOURCE_CONTEXT;
+    }
+    getRequestPriority(_request, _context) {
+        return 0 /* RequestPriority.LOW */;
     }
 }
 
@@ -4029,6 +4042,27 @@ async function runRequestsWithLimit(requests, runner, concurrentRequestsLimit, p
     // Wait for all initial requests to complete
     await Promise.all(promises);
 }
+/**
+ * Runs entire list of LEX requests, applying hotspot up to the specified limit and disabling for all remaining
+ *
+ * @param {RequestEntry<LexRequest>[]} requests - An array of request entries to be processed in the array order.
+ * @param {RequestRunner<LexRequest, LexRequestOptions>} runner - The runner instance responsible for executing the requests.
+ * @param {number} hotspotLimit - The number of hotspot requests allowed.
+ * @returns {Promise<void>} A promise that resolves when all requests have been processed.
+ *
+ * This function processes a queue of pending requests, enabling hotspot for the first N requests,
+ * as specified by the hotspotLimit argument.  The remaining requests have hotspot disabled.
+ */
+async function runRequestsWithHotspotLimit(requests, runner, hotspotLimit) {
+    const promises = requests.map((request, index) => {
+        // determine if hotspot needs to be disabled or not
+        const disableHotspot = index >= hotspotLimit;
+        // run request with hotspot setting
+        return runner.runRequest(request.request, { disableHotspot });
+    });
+    // promise for all requests
+    await Promise.all(promises);
+}
 /**
  * Compares two request entries based on their priority and, if the priorities are the same, their request times.
  * This function is typically used for sorting requests where priority takes precedence, and timing is used
@@ -4062,6 +4096,16 @@ function compareByPriorityThenTime({ request: requestA, requestMetadata: request
         return bPriority - aPriority;
     }
 }
+/**
+ * Returns the value of the gate that controls whether to use the hotspot limit.  Value is cached after the initial call
+ *
+ * @returns {boolean} true if the gate is open, false otherwise.
+ */
+let useHotspotLimitOpen;
+function isUseHotspotLimitOpen() {
+    useHotspotLimitOpen = useHotspotLimitOpen ?? useHotspotLimit.isOpen({ fallback: false });
+    return useHotspotLimitOpen;
+}
 
 function isBoxcarableRequest({ request: { adapterName } }, requestStrategyManager) {
     const strategy = requestStrategyManager.get(adapterName);
@@ -4072,6 +4116,7 @@ function predictNonBoxcarableRequest(nonBoxcaredPredictions, requestRunner) {
     reducedPredictions.map((request) => requestRunner.runRequest(request.request));
 }
 const DEFAULT_RECORD_TYPE_ID = '012000000000000AAA';
+const AURA_BOXCAR_THREADS_THRESHOLD = 3;
 class LexPredictivePrefetcher extends ApplicationPredictivePrefetcher {
     constructor(context, repository, requestRunner, 
     // These strategies need to be in sync with the "predictiveDataLoadCapable" list
@@ -4107,7 +4152,7 @@ class LexPredictivePrefetcher extends ApplicationPredictivePrefetcher {
         const similarPageRequests = this.getSimilarPageRequests();
         return [...exactPageRequests, ...similarPageRequests];
     }
-    async predict() {
+    getPredictedRequestsOrderedByPriority() {
         // perf: caching access, to avoid this.prop in loops.
         const { requestStrategyManager, context } = this;
         const alwaysRequests = this.page.getAlwaysRunRequests();
@@ -4130,16 +4175,26 @@ class LexPredictivePrefetcher extends ApplicationPredictivePrefetcher {
         // Sorting in order requested
         reducedPredictions.sort((a, b) => compareByPriorityThenTime(a, b, requestStrategyManager, context));
         // When available, alwaysRequestEntries are prioritized.
-        const predictedRequestsWithLimit = this.page.shouldExecuteAlwaysRequestByThemself()
+        return this.page.shouldExecuteAlwaysRequestByThemself()
             ? [...alwaysRequestEntries, ...reducedPredictions]
             : reducedPredictions;
-        this.totalRequestCount = predictedRequestsWithLimit.length;
-        await runRequestsWithLimit(predictedRequestsWithLimit, this.requestRunner, this.options.inflightRequestLimit, 
-        // `this.repository.pageStartTime` would be the correct here,
-        // but when doing predict+watch, it could be (set in watch)
-        // repository.startTime is not set yet, Date.now() is a better alternative,
-        // that is correct, and works on both cases.
-        Date.now());
+    }
+    async predict() {
+        const requests = this.getPredictedRequestsOrderedByPriority();
+        this.totalRequestCount = requests.length;
+        if (isUseHotspotLimitOpen()) {
+            await runRequestsWithHotspotLimit(requests, this.requestRunner, Math.floor(this.options.inflightRequestLimit / 2));
+        }
+        else {
+            await runRequestsWithLimit(requests, this.requestRunner, 
+            // don't get available thread count below threshold else Aura will boxcar
+            this.options.inflightRequestLimit - AURA_BOXCAR_THREADS_THRESHOLD, 
+            // `this.repository.pageStartTime` would be the correct here,
+            // but when doing predict+watch, it could be (set in watch)
+            // repository.startTime is not set yet, Date.now() is a better alternative,
+            // that is correct, and works on both cases.
+            Date.now());
+        }
     }
 }
 
@@ -4154,10 +4209,10 @@ class LexRequestRunner {
             .map((strategy) => strategy.reduce(requests))
             .flat();
     }
-    runRequest(request) {
+    runRequest(request, options = {}) {
         const strategy = this.requestStrategyManager.get(request.adapterName);
         if (strategy) {
-            return Promise.resolve(strategy.execute(request.config)).then();
+            return Promise.resolve(strategy.execute(request.config, options)).then();
         }
         return Promise.resolve(undefined);
     }
@@ -4290,7 +4345,7 @@ function getEnvironmentSetting(name) {
     }
     return undefined;
 }
-// version: 1.328.0-e51e28f7fc
+// version: 1.329.0-beac2bb064
 
 const forceRecordTransactionsDisabled = getEnvironmentSetting(EnvironmentSettings.ForceRecordTransactionsDisabled);
 //TODO: Some duplication here that can be most likely moved to a util class
@@ -4738,7 +4793,7 @@ let __lexPrefetcher;
 const HARDCODED_REQUEST_LIMIT = 9;
 function getInflightRequestLimit() {
     try {
-        return window['$A'].clientService.maxAllowedParallelXHRCounts() - 3;
+        return window['$A'].clientService.maxAllowedParallelXHRCounts();
     }
     catch (e) {
         return HARDCODED_REQUEST_LIMIT;
@@ -4989,4 +5044,4 @@ function ldsEngineCreator() {
 }
 
 export { LexRequestStrategy, PdlRequestPriority, buildPredictorForContext, ldsEngineCreator as default, initializeLDS, initializeOneStore, registerRequestStrategy, saveRequestAsPrediction, unregisterRequestStrategy, whenPredictionsReady };
-// version: 1.328.0-f3d79bc783
+// version: 1.329.0-9b52e8059d

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

@@ -11,4 +11,7 @@ export type LexPrefetcherOptions = {
 };
 export { PredictionsReadyManager } from './predictions-ready-manager';
 export type LexRequest<Config = unknown> = BaseAdapterRequest<Config>;
+export type LexRequestOptions = {
+    disableHotspot?: boolean;
+};
 export type LexContext = RecordHomePageContext | ObjectHomePageContext | DefaultPageContext;

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

@@ -12,5 +12,6 @@ export declare class LexPredictivePrefetcher extends ApplicationPredictivePrefet
     constructor(context: LexContext, repository: PrefetchRepository<LexRequest>, requestRunner: RequestRunner<LexRequest>, requestStrategyManager: RequestStrategyManager, options: LexPrefetcherOptions);
     getPage(): LexDefaultPage<LexRequest, LexContext>;
     getAllPageRequests(): RequestEntry<LexRequest>[];
+    getPredictedRequestsOrderedByPriority(): RequestEntry<LexRequest>[];
     predict(): Promise<void>;
 }

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

@@ -1,6 +1,6 @@
 import type { RequestRunner } from '../request-runner';
 import type { RequestEntry } from '../common';
-import type { LexRequest } from '../lex';
+import type { LexRequest, LexRequestOptions } from '../lex';
 import type { RequestStrategyManager } from '../request-strategy-manager/request-strategy-manager';
 import type { DefaultPageContext } from '../pages';
 /**
@@ -17,6 +17,18 @@ import type { DefaultPageContext } from '../pages';
  * Requests are only processed if their `requestTime` is less than the time elapsed since `pageStartTime`.
  */
 export declare function runRequestsWithLimit<Request>(requests: RequestEntry<Request>[], runner: RequestRunner<Request>, concurrentRequestsLimit: number, pageStartTime: number): Promise<void>;
+/**
+ * Runs entire list of LEX requests, applying hotspot up to the specified limit and disabling for all remaining
+ *
+ * @param {RequestEntry<LexRequest>[]} requests - An array of request entries to be processed in the array order.
+ * @param {RequestRunner<LexRequest, LexRequestOptions>} runner - The runner instance responsible for executing the requests.
+ * @param {number} hotspotLimit - The number of hotspot requests allowed.
+ * @returns {Promise<void>} A promise that resolves when all requests have been processed.
+ *
+ * This function processes a queue of pending requests, enabling hotspot for the first N requests,
+ * as specified by the hotspotLimit argument.  The remaining requests have hotspot disabled.
+ */
+export declare function runRequestsWithHotspotLimit(requests: RequestEntry<LexRequest>[], runner: RequestRunner<LexRequest, LexRequestOptions>, hotspotLimit: number): Promise<void>;
 /**
  * Compares two request entries based on their priority and, if the priorities are the same, their request times.
  * This function is typically used for sorting requests where priority takes precedence, and timing is used
@@ -37,3 +49,4 @@ export declare function runRequestsWithLimit<Request>(requests: RequestEntry<Req
  *                   the priority defaults to `RequestPriority.LOW`.
  */
 export declare function compareByPriorityThenTime<Context extends DefaultPageContext = DefaultPageContext>({ request: requestA, requestMetadata: requestMetadataA }: RequestEntry<LexRequest>, { request: requestB, requestMetadata: requestMetadataB }: RequestEntry<LexRequest>, requestStrategyManager: RequestStrategyManager, context: Context): number;
+export declare function isUseHotspotLimitOpen(): boolean;

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

@@ -1,10 +1,10 @@
 import type { RequestRunner } from './request-runner';
 import type { RequestEntry } from '../common';
-import type { LexRequest } from '../lex';
+import type { LexRequest, LexRequestOptions } from '../lex';
 import type { RequestStrategyManager } from '../request-strategy-manager/request-strategy-manager';
-export declare class LexRequestRunner implements RequestRunner<LexRequest> {
+export declare class LexRequestRunner implements RequestRunner<LexRequest, LexRequestOptions> {
     private requestStrategyManager;
     constructor(requestStrategyManager: RequestStrategyManager);
     reduceRequests(requests: RequestEntry<LexRequest>[]): RequestEntry<LexRequest>[];
-    runRequest(request: LexRequest): Promise<void>;
+    runRequest(request: LexRequest, options?: LexRequestOptions): Promise<void>;
 }

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

@@ -1,5 +1,5 @@
 import type { RequestEntry } from '../common';
-export type RequestRunner<Request> = {
-    runRequest(request: Request): Promise<void>;
+export type RequestRunner<Request, Options = Record<string, any>> = {
+    runRequest(request: Request, options?: Options): Promise<void>;
     reduceRequests(requests: RequestEntry<Request>[]): RequestEntry<Request>[];
 };

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

@@ -1,6 +1,8 @@
 import type { ApexInvokerParams } from '@salesforce/lds-adapters-apex';
-import type { AdapterRequestContext, Luvio, Snapshot } from '@luvio/engine';
+import type { AdapterRequestContext, Luvio } from '@luvio/engine';
 import { LuvioAdapterRequestStrategy } from './luvio-adapter-request-strategy';
+import { RequestPriority } from './request-strategy';
+import type { LexRequestOptions } from '../lex';
 export type GetApexConfig = {
     name: string;
     invokerParams: ApexInvokerParams;
@@ -10,13 +12,19 @@ export type GetApexRequest = {
     adapterName: 'getApex';
     config: GetApexConfig;
 };
-export declare function getApexPdlFactory(luvio: Luvio): ({ invokerParams, config }: GetApexConfig, requestContext?: AdapterRequestContext) => Snapshot<any> | Promise<Snapshot<any>> | null;
+export declare function getApexPdlFactory(luvio: Luvio): ({ invokerParams, config }: GetApexConfig, requestContext?: AdapterRequestContext) => import("@luvio/engine").Snapshot<any> | Promise<import("@luvio/engine").Snapshot<any>> | null;
 type GetApexContext = Record<string, unknown>;
 export declare const GET_APEX_ADAPTER_NAME = "getApex";
 export declare class GetApexRequestStrategy extends LuvioAdapterRequestStrategy<GetApexConfig, GetApexRequest, GetApexContext> {
     adapterName: string;
     adapterFactory: typeof getApexPdlFactory;
     buildConcreteRequest(similarRequest: GetApexRequest): GetApexRequest;
-    execute(config: GetApexConfig, _requestContext?: AdapterRequestContext | undefined): Snapshot<any> | Promise<Snapshot<any>> | null;
+    protected createAdapterContext(_options: LexRequestOptions): {
+        sourceContext: {
+            actionConfig: undefined;
+            tagName: string;
+        };
+    };
+    getRequestPriority(_request: GetApexRequest, _context: GetApexContext): RequestPriority;
 }
 export {};

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

@@ -1,7 +1,7 @@
 import { RequestStrategy } from './request-strategy';
-import type { LexContext, LexRequest } from '../lex';
+import type { LexContext, LexRequest, LexRequestOptions } from '../lex';
 import type { DefaultPageContext } from '../pages';
-export declare abstract class LexRequestStrategy<Config = unknown, Request extends LexRequest<Config> = LexRequest<Config>, Context extends LexContext = DefaultPageContext> extends RequestStrategy<Config, Request, Context> {
+export declare abstract class LexRequestStrategy<Config = unknown, Request extends LexRequest<Config> = LexRequest<Config>, Context extends LexContext = DefaultPageContext> extends RequestStrategy<Config, Request, Context, LexRequestOptions> {
     /**
      * Whether or not requests from this strategies can be boxcarred by Aura.
      * If they are, the lex prefetcher will run predictions of this strategy with a limit,

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

@@ -1,6 +1,6 @@
-import type { AdapterFactory, AdapterRequestContext, Luvio, Snapshot } from '@luvio/engine';
+import type { AdapterFactory, Luvio, Snapshot } from '@luvio/engine';
 import { LexRequestStrategy } from './lex-request-strategy';
-import type { LexContext, LexRequest } from '../lex';
+import type { LexContext, LexRequest, LexRequestOptions } from '../lex';
 export declare const DEFAULT_RESOURCE_CONTEXT: {
     sourceContext: {
         tagName: string;
@@ -22,5 +22,6 @@ export declare abstract class LuvioAdapterRequestStrategy<AdapterConfig, Request
      * Factory for the adapter used in this strategy.
      */
     abstract adapterFactory: AdapterFactory<AdapterConfig, any>;
-    execute(config: AdapterConfig, requestContext?: AdapterRequestContext): Snapshot<any> | Promise<Snapshot<any>> | null;
+    execute(config: AdapterConfig, options?: LexRequestOptions): Snapshot<any> | Promise<Snapshot<any>> | null;
+    protected createAdapterContext(options: LexRequestOptions): any;
 }

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

@@ -13,12 +13,12 @@ export declare enum PdlRequestPriority {
     NORMAL = 1,
     HIGH = 2
 }
-export declare abstract class RequestStrategy<Config, Request extends BaseAdapterRequest<Config>, Context> {
+export declare abstract class RequestStrategy<Config, Request extends BaseAdapterRequest<Config>, Context, Options extends Record<string, any>> {
     /**
      * Name of the adapter used in this strategy.
      */
     abstract adapterName: string;
-    abstract execute(config: Config): any;
+    abstract execute(config: Config, options?: Options): any;
     abstract buildConcreteRequest(similarRequest: Request, context: Context): Request;
     getRequestPriority(_request: Request, _context: Context): RequestPriority;
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@salesforce/lds-runtime-aura",
-    "version": "1.328.0",
+    "version": "1.329.0",
     "license": "SEE LICENSE IN LICENSE.txt",
     "description": "LDS engine for Aura runtime",
     "main": "dist/ldsEngineCreator.js",
@@ -34,42 +34,42 @@
         "release:corejar": "yarn build && ../core-build/scripts/core.js --name=lds-runtime-aura"
     },
     "devDependencies": {
-        "@luvio/service-provisioner": "5.17.0",
-        "@salesforce/lds-adapters-apex": "^1.328.0",
-        "@salesforce/lds-adapters-uiapi": "^1.328.0",
+        "@luvio/service-provisioner": "5.21.0",
+        "@salesforce/lds-adapters-apex": "^1.329.0",
+        "@salesforce/lds-adapters-uiapi": "^1.329.0",
         "@salesforce/lds-adapters-uiapi-lex": "^1.302.0",
-        "@salesforce/lds-ads-bridge": "^1.328.0",
-        "@salesforce/lds-aura-storage": "^1.328.0",
-        "@salesforce/lds-bindings": "^1.328.0",
-        "@salesforce/lds-instrumentation": "^1.328.0",
-        "@salesforce/lds-network-aura": "^1.328.0",
-        "@salesforce/lds-network-fetch-with-jwt": "^1.328.0",
+        "@salesforce/lds-ads-bridge": "^1.329.0",
+        "@salesforce/lds-aura-storage": "^1.329.0",
+        "@salesforce/lds-bindings": "^1.329.0",
+        "@salesforce/lds-instrumentation": "^1.329.0",
+        "@salesforce/lds-network-aura": "^1.329.0",
+        "@salesforce/lds-network-fetch-with-jwt": "^1.329.0",
         "jwt-encode": "1.0.1"
     },
     "dependencies": {
-        "@luvio/command-aura-network": "5.17.0",
-        "@luvio/command-aura-resource-cache-control": "5.17.0",
-        "@luvio/command-fetch-network": "5.17.0",
-        "@luvio/command-network": "5.17.0",
-        "@luvio/command-sse": "5.17.0",
-        "@luvio/command-streaming": "5.17.0",
+        "@luvio/command-aura-network": "5.21.0",
+        "@luvio/command-aura-resource-cache-control": "5.21.0",
+        "@luvio/command-fetch-network": "5.21.0",
+        "@luvio/command-network": "5.21.0",
+        "@luvio/command-sse": "5.21.0",
+        "@luvio/command-streaming": "5.21.0",
         "@luvio/network-adapter-composable": "0.156.5",
         "@luvio/network-adapter-fetch": "0.156.5",
-        "@luvio/service-aura-network": "5.17.0",
-        "@luvio/service-cache": "5.17.0",
-        "@luvio/service-cache-control": "5.17.0",
-        "@luvio/service-fetch-network": "5.17.0",
-        "@luvio/service-instrument-command": "5.17.0",
-        "@luvio/service-store": "5.17.0",
-        "@luvio/utils": "5.17.0",
-        "@salesforce/lds-adapters-uiapi-lex": "^1.328.0"
+        "@luvio/service-aura-network": "5.21.0",
+        "@luvio/service-cache": "5.21.0",
+        "@luvio/service-cache-control": "5.21.0",
+        "@luvio/service-fetch-network": "5.21.0",
+        "@luvio/service-instrument-command": "5.21.0",
+        "@luvio/service-store": "5.21.0",
+        "@luvio/utils": "5.21.0",
+        "@salesforce/lds-adapters-uiapi-lex": "^1.329.0"
     },
     "luvioBundlesize": [
         {
             "path": "./dist/ldsEngineCreator.js",
             "maxSize": {
-                "none": "187 kB",
-                "min": "78 kB",
+                "none": "189 kB",
+                "min": "78.5 kB",
                 "compressed": "34 kB"
             }
         }