@adobe/alloy 2.36.0-beta.1 → 2.36.1-beta.0

package/dist/types/browser/src/services/injectSendFetchRequest.d.ts

@@ -1,4 +1,8 @@
-declare function _default({ fetch }: {
-    fetch: any;
-}): (url: any, body: any, headers: any) => any;
+declare function _default({ fetch, logger }: {
+    fetch: typeof window.fetch;
+    logger: {
+        info: (...args: any[]) => void;
+    };
+}): NetworkService["sendFetchRequest"];
 export default _default;
+import type { NetworkService } from "@adobe/alloy-core/services";

package/dist/types/core/src/core/network/injectSendNetworkRequest.d.ts

@@ -4,11 +4,12 @@ declare function _default({ logger, sendFetchRequest, sendBeaconRequest, isReque
     sendBeaconRequest: any;
     isRequestRetryable: any;
     getRequestRetryDelay: any;
-}): ({ requestId, url, payload, useSendBeacon, headers }: {
+}): ({ requestId, url, payload, useSendBeacon, useKeepalive, headers, }: {
     requestId: any;
     url: any;
     payload: any;
     useSendBeacon: any;
+    useKeepalive: any;
     headers: any;
 }) => any;
 export default _default;

package/dist/types/core/src/services/types.d.ts

@@ -2,8 +2,24 @@ export type NetworkResponse = {
     statusCode: number;
     body: string;
     getHeader: (name: string) => (string | null);
+    /**
+     * `true` when the request was handed to `navigator.sendBeacon`. The browser
+     * gives no response for these, so `statusCode`, `body`, and `getHeader` are
+     * placeholders rather than values from the server.
+     */
+    sentWithBeacon?: boolean | undefined;
+};
+export type SendFetchRequestOptions = {
+    /**
+     * Send the request with `keepalive` so the
+     * browser finishes it even if the page unloads. Implementations fall back to
+     * a regular request if the browser refuses (for example, when in-flight
+     * keepalive data on the page would exceed 64 KiB). Ignored where there is no
+     * page to unload (Node).
+     */
+    keepalive?: boolean | undefined;
 };
-export type SendFetchRequest = (url: string, body: string) => Promise<NetworkResponse>;
+export type SendFetchRequest = (url: string, body: string, headers?: Record<string, string>, options?: SendFetchRequestOptions) => Promise<NetworkResponse>;
 export type SendBeaconRequest = (url: string, body: string) => Promise<NetworkResponse>;
 export type NetworkService = {
     /**

package/dist/types/core/src/utils/request/createRequest.d.ts

@@ -6,6 +6,7 @@ declare function _default(options: {
     getUseSendBeacon: (arg0: {
         isIdentityEstablished: boolean;
     }) => boolean;
+    getUseKeepalive?: (() => boolean) | undefined;
     datastreamIdOverride?: string | undefined;
     edgeSubPath?: string | undefined;
 }): Request;

package/dist/types/core/src/utils/request/types.d.ts

@@ -7,6 +7,7 @@
  * @property {function({isIdentityEstablished: boolean}): string}  getAction
  * @property {function(): string|undefined} getDatastreamIdOverride
  * @property {Function} getUseSendBeacon
+ * @property {function(): boolean} getUseKeepalive
  * @property {function(): string|undefined} getEdgeSubPath
  * @property {Function} getUseIdThirdPartyDomain
  * @property {Function} setUseIdThirdPartyDomain
@@ -55,6 +56,7 @@ export type Request = {
     }) => string;
     getDatastreamIdOverride: () => string | undefined;
     getUseSendBeacon: Function;
+    getUseKeepalive: () => boolean;
     getEdgeSubPath: () => string | undefined;
     getUseIdThirdPartyDomain: Function;
     setUseIdThirdPartyDomain: Function;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adobe/alloy",
-  "version": "2.36.0-beta.1",
+  "version": "2.36.1-beta.0",
   "description": "Adobe Experience Platform Web SDK",
   "type": "module",
   "repository": {
@@ -69,7 +69,7 @@
     "commander": "^14.0.2",
     "rollup": "^4.60.3",
     "rollup-plugin-license": "^3.7.1",
-    "@adobe/alloy-core": "^1.3.0-beta.1"
+    "@adobe/alloy-core": "^1.3.1-beta.0"
   },
   "devDependencies": {
     "glob": "^13.0.6",
@@ -86,7 +86,9 @@
     "release": "node scripts/release.mjs",
     "build:types": "tsc -p jsconfig.json --declaration --emitDeclarationOnly --outDir dist/types --checkJs false --noEmit false",
     "build": "pnpm run clean && rollup -c --environment BASE_CODE_MIN,STANDALONE,STANDALONE_MIN,SERVICE_WORKER,SERVICE_WORKER_MIN,UTILITY_EXPORTS,BUNDLESIZE && pnpm run build:types",
-    "build:watch": "pnpm run clean && rollup -c --watch --environment BASE_CODE_MIN,STANDALONE,UTILITY_EXPORTS",
+    "build:watch": "rollup -c --watch --environment BASE_CODE_MIN,STANDALONE,SERVICE_WORKER,UTILITY_EXPORTS",
+    "dev:prepare": "rollup -c --environment BASE_CODE_MIN,STANDALONE,SERVICE_WORKER,UTILITY_EXPORTS",
+    "dev": "pnpm run build:watch",
     "build:custom": "node scripts/alloyBuilder.js",
     "test:functional": "pnpm exec playwright install chromium && EDGE_BASE_PATH=\"ee-pre-prd\" ALLOY_ENV=\"int\" testcafe playwright:chromium",
     "test:functional:custom": "node ./scripts/runFunctionalTests.js",

package/src/services/createBrowserNetworkService.js

@@ -21,7 +21,7 @@ import injectSendBeaconRequest from "./injectSendBeaconRequest.js";
  */
 const createBrowserNetworkService = ({ logger }) => {
   const { fetch, navigator } = window;
-  const sendFetchRequest = injectSendFetchRequest({ fetch });
+  const sendFetchRequest = injectSendFetchRequest({ fetch, logger });
   const sendBeaconRequest =
     typeof navigator.sendBeacon === "function"
       ? injectSendBeaconRequest({

package/src/services/injectSendBeaconRequest.js

@@ -20,13 +20,15 @@ export default ({ sendBeacon, sendFetchRequest, logger }) => {
 
     // Using sendBeacon, we technically don't get a response back from
     // the server, but we'll resolve the promise with an object to maintain
-    // consistency with other network strategies.
+    // consistency with other network strategies. `sentWithBeacon` marks the
+    // response as synthetic so it isn't logged as a real server response.
     return Promise.resolve({
       statusCode: 204,
       getHeader() {
         return null;
       },
       body: "",
+      sentWithBeacon: true,
     });
   };
 };

package/src/services/injectSendFetchRequest.js

@@ -10,9 +10,23 @@ OF ANY KIND, either express or implied. See the License for the specific languag
 governing permissions and limitations under the License.
 */
 
-export default ({ fetch }) => {
-  return (url, body, headers) => {
-    return fetch(url, {
+/** @import { NetworkService } from "@adobe/alloy-core/services" */
+
+/**
+ * @param {Object} params
+ * @param {typeof window.fetch} params.fetch
+ * @param {{ info: (...args: any[]) => void }} params.logger
+ * @returns {NetworkService["sendFetchRequest"]}
+ */
+export default ({ fetch, logger }) => {
+  /**
+   * @param {string} url
+   * @param {string} body
+   * @param {Record<string, string> | undefined} headers
+   * @param {boolean} keepalive
+   */
+  const startFetch = (url, body, headers, keepalive) =>
+    fetch(url, {
       method: "POST",
       cache: "no-cache",
       credentials: "include", // To set the cookie header in the request.
@@ -22,7 +36,30 @@ export default ({ fetch }) => {
       },
       referrerPolicy: "no-referrer-when-downgrade",
       body,
-    }).then((response) => {
+      ...(keepalive ? { keepalive: true } : {}),
+    });
+
+  return (url, body, headers, { keepalive = false } = {}) => {
+    let responsePromise = startFetch(url, body, headers, keepalive);
+
+    if (keepalive) {
+      // Browsers reject keepalive requests whose body, together with every
+      // other in-flight keepalive request and sendBeacon on the page, exceeds
+      // 64 KiB. The rejection is a TypeError that looks the same as any other
+      // network error ("Failed to fetch", "NetworkError when attempting to
+      // fetch resource.", "Load failed") and arrives before anything is sent,
+      // so retry once without keepalive. Only fetch() itself is covered here;
+      // a failure while reading the response is not retried because the
+      // server already received the request.
+      responsePromise = responsePromise.catch(() => {
+        logger.info(
+          "Unable to send the request with `keepalive`; falling back to a regular `fetch`.",
+        );
+        return startFetch(url, body, headers, false);
+      });
+    }
+
+    return responsePromise.then((response) => {
       return response.text().then((responseBody) => ({
         statusCode: response.status,
         // We expose headers through a function instead of creating an object