@warp-drive/utilities 5.9.0-alpha.2 → 5.9.0-alpha.21

package/dist/unpkg/prod-deprecated/handlers.js

@@ -1,305 +1,264 @@
+//#region src/-private/handlers/auto-compress.ts
 function isCompressibleMethod(method) {
-  return method === 'POST' || method === 'PUT' || method === 'PATCH' || method === 'DELETE';
+	return method === "POST" || method === "PUT" || method === "PATCH" || method === "DELETE";
 }
-
 /**
- * Whether the browser supports `ReadableStream` as a request body
- * in a `POST` request.
- *
- * @group Constants
- */
+* Whether the browser supports `ReadableStream` as a request body
+* in a `POST` request.
+*
+* @group Constants
+*/
 const SupportsRequestStreams = (() => {
-  let duplexAccessed = false;
-  const hasContentType = new Request('', {
-    body: new ReadableStream(),
-    method: 'POST',
-    // @ts-expect-error untyped
-    get duplex() {
-      duplexAccessed = true;
-      return 'half';
-    }
-  }).headers.has('Content-Type');
-  return duplexAccessed && !hasContentType;
+	let duplexAccessed = false;
+	const hasContentType = new Request("", {
+		body: new ReadableStream(),
+		method: "POST",
+		get duplex() {
+			duplexAccessed = true;
+			return "half";
+		}
+	}).headers.has("Content-Type");
+	return duplexAccessed && !hasContentType;
 })();
-
 /**
- * Options for configuring the AutoCompress handler.
- *
- */
-
+* Options for configuring the AutoCompress handler.
+*
+*/
 const DEFAULT_CONSTRAINTS = {
-  Blob: 1000,
-  ArrayBuffer: 1000,
-  TypedArray: 1000,
-  DataView: 1000,
-  String: 1000
+	Blob: 1e3,
+	ArrayBuffer: 1e3,
+	TypedArray: 1e3,
+	DataView: 1e3,
+	String: 1e3
 };
 const TypedArray = Object.getPrototypeOf(Uint8Array);
-
 /**
- * A request handler that automatically compresses the request body
- * if the request body is a string, array buffer, blob, or form data.
- *
- * This uses the [CompressionStream API](https://developer.mozilla.org/en-US/docs/Web/API/CompressionStream)
- *
- * The compression format as well as the kinds of data to compress can be
- * configured using the `format` and `constraints` options.
- *
- * ```diff
- * +import { AutoCompress } from '@ember-data/request-utils/handlers';
- * import Fetch from '@ember-data/request/fetch';
- * import RequestManager from '@ember-data/request';
- * import Store from '@ember-data/store';
- *
- * class AppStore extends Store {
- *   requestManager = new RequestManager()
- *     .use([
- * +       new AutoCompress(),
- *        Fetch
- *     ]);
- * }
- * ```
- *
- * @group Handlers
- * @public
- * @since 5.5.0
- */
-class AutoCompress {
-  constructor(options = {}) {
-    const opts = {
-      format: options.format ?? 'gzip',
-      constraints: Object.assign({}, DEFAULT_CONSTRAINTS, options.constraints),
-      allowStreaming: options.allowStreaming ?? false,
-      forceStreaming: options.forceStreaming ?? false
-    };
-    this.options = opts;
-  }
-  request({
-    request
-  }, next) {
-    const {
-      constraints
-    } = this.options;
-    const {
-      body
-    } = request;
-    const shouldCompress = !!body && isCompressibleMethod(request.method) && request.options?.compress !== false && (
-    // prettier-ignore
-    request.options?.compress ? true : typeof body === 'string' || body instanceof String ? canCompress('String', constraints, body.length) : body instanceof Blob ? canCompress('Blob', constraints, body.size) : body instanceof ArrayBuffer ? canCompress('ArrayBuffer', constraints, body.byteLength) : body instanceof DataView ? canCompress('DataView', constraints, body.byteLength) : body instanceof TypedArray ? canCompress('TypedArray', constraints, body.byteLength) : false);
-    if (!shouldCompress) return next(request);
-
-    // A convenient way to convert all of the supported body types to a readable
-    // stream is to use a `Response` object body
-    const response = new Response(request.body);
-    const stream = response.body?.pipeThrough(new CompressionStream(this.options.format));
-    const headers = new Headers(request.headers);
-    headers.set('Content-Encoding', encodingForFormat(this.options.format));
-
-    //
-    // For browsers that support it, `fetch` can receive a `ReadableStream` as
-    // the body, so all we need to do is to create a new `ReadableStream` and
-    // compress it on the fly
-    //
-    const forceStreaming = request.options?.forceStreaming ?? this.options.forceStreaming;
-    const allowStreaming = request.options?.allowStreaming ?? this.options.allowStreaming;
-    if (forceStreaming || SupportsRequestStreams && allowStreaming) {
-      const req = Object.assign({}, request, {
-        body: stream,
-        headers
-      });
-      if (SupportsRequestStreams) {
-        // @ts-expect-error untyped
-        req.duplex = 'half';
-      }
-      return next(req);
-
-      //
-      // For non-chromium browsers, we have to "pull" the stream to get the final
-      // bytes and supply the final byte array as the new request body.
-      //
-    }
-
-    // we need to pull the stream to get the final bytes
-    const resp = new Response(stream);
-    return resp.blob().then(blob => {
-      const req = Object.assign({}, request, {
-        body: blob,
-        headers
-      });
-      return next(req);
-    });
-  }
-}
+* A request handler that automatically compresses the request body
+* if the request body is a string, array buffer, blob, or form data.
+*
+* This uses the [CompressionStream API](https://developer.mozilla.org/en-US/docs/Web/API/CompressionStream)
+*
+* The compression format as well as the kinds of data to compress can be
+* configured using the `format` and `constraints` options.
+*
+* ```diff
+* +import { AutoCompress } from '@ember-data/request-utils/handlers';
+* import Fetch from '@ember-data/request/fetch';
+* import RequestManager from '@ember-data/request';
+* import Store from '@ember-data/store';
+*
+* class AppStore extends Store {
+*   requestManager = new RequestManager()
+*     .use([
+* +       new AutoCompress(),
+*        Fetch
+*     ]);
+* }
+* ```
+*
+* @group Handlers
+* @public
+* @since 5.5.0
+*/
+var AutoCompress = class {
+	/**
+	* The resolved options this handler was configured with, with all
+	* defaults (including `constraints` defaults) applied.
+	*/
+	constructor(options = {}) {
+		const opts = {
+			format: options.format ?? "gzip",
+			constraints: Object.assign({}, DEFAULT_CONSTRAINTS, options.constraints),
+			allowStreaming: options.allowStreaming ?? false,
+			forceStreaming: options.forceStreaming ?? false
+		};
+		this.options = opts;
+	}
+	request({ request }, next) {
+		const { constraints } = this.options;
+		const { body } = request;
+		if (!(!!body && isCompressibleMethod(request.method) && request.options?.compress !== false && (request.options?.compress ? true : typeof body === "string" || body instanceof String ? canCompress("String", constraints, body.length) : body instanceof Blob ? canCompress("Blob", constraints, body.size) : body instanceof ArrayBuffer ? canCompress("ArrayBuffer", constraints, body.byteLength) : body instanceof DataView ? canCompress("DataView", constraints, body.byteLength) : body instanceof TypedArray ? canCompress("TypedArray", constraints, body.byteLength) : false))) return next(request);
+		const stream = new Response(request.body).body?.pipeThrough(new CompressionStream(this.options.format));
+		const headers = new Headers(request.headers);
+		headers.set("Content-Encoding", encodingForFormat(this.options.format));
+		const forceStreaming = request.options?.forceStreaming ?? this.options.forceStreaming;
+		const allowStreaming = request.options?.allowStreaming ?? this.options.allowStreaming;
+		if (forceStreaming || SupportsRequestStreams && allowStreaming) {
+			const req = Object.assign({}, request, {
+				body: stream,
+				headers
+			});
+			if (SupportsRequestStreams) req.duplex = "half";
+			return next(req);
+		}
+		return new Response(stream).blob().then((blob) => {
+			return next(Object.assign({}, request, {
+				body: blob,
+				headers
+			}));
+		});
+	}
+};
 function canCompress(type, constraints, size) {
-  // if we have a value of 0, we can compress anything
-  if (constraints[type] === 0) return true;
-  if (constraints[type] === -1) return false;
-  return size >= constraints[type];
+	if (constraints[type] === 0) return true;
+	if (constraints[type] === -1) return false;
+	return size >= constraints[type];
 }
 function encodingForFormat(format) {
-  switch (format) {
-    case 'gzip':
-    case 'deflate':
-    case 'deflate-raw':
-      return format;
-    default:
-      // @ts-expect-error - unreachable code is reachable in production
-      return format;
-  }
+	switch (format) {
+		case "gzip":
+		case "deflate":
+		case "deflate-raw": return format;
+		default: return format;
+	}
 }
 
+//#endregion
+//#region src/-private/handlers/gated.ts
 /**
- * If CheckFn returns true, the wrapped handler will be used.
- * If CheckFn returns false, the wrapped handler will be skipped.
- */
-
+* If CheckFn returns true, the wrapped handler will be used.
+* If CheckFn returns false, the wrapped handler will be skipped.
+*/
 /**
- *
- * @group Handlers
- * @public
- */
-class Gate {
-  constructor(handler, checkFn) {
-    this.handler = handler;
-    this.checkFn = checkFn;
-  }
-  request(context, next) {
-    if (this.checkFn(context)) {
-      return this.handler.request(context, next);
-    }
-    return next(context.request);
-  }
-}
+*
+* @group Handlers
+* @public
+*/
+var Gate = class {
+	/**
+	* The wrapped handler to invoke when {@link Gate.checkFn | checkFn} returns `true`.
+	*/
+	/**
+	* The predicate used to decide whether {@link Gate.handler | handler} should run for a given request.
+	*/
+	constructor(handler, checkFn) {
+		this.handler = handler;
+		this.checkFn = checkFn;
+	}
+	request(context, next) {
+		if (this.checkFn(context)) return this.handler.request(context, next);
+		return next(context.request);
+	}
+};
 
+//#endregion
+//#region src/-private/handlers/meta-doc.ts
 /**
- * MetaDocHandler processes requests that are marked as meta requests.
- *
- * It treats the response body as "entirely meta" transforming
- *
- * ```ts
- * {
- *   some: "key",
- *   another: "thing"
- * }
- * ```
- *
- * into
- *
- * ```ts
- * {
- * 	 meta: {
- *     some: "key",
- *     another: "thing"
- *   }
- * }
- * ```
- *
- * To activate this handler, a request should specify
- *
- * ```ts
- * options.isMetaRequest = true
- * ```
- *
- * For instance
- *
- * ```ts
- * store.request({
- *   url: '/example',
- *   options: {
- *     isMetaRequest: true
- *   }
- * });
- * ```
- *
- * Errors are not processed by this handler, so if the request fails and the error response
- * is not in {json:api} format additional processing may be needed.
- *
- * @group Handlers
- */
-const MetaDocHandler = {
-  request(context, next) {
-    if (!context.request.options?.isMetaRequest) {
-      return next(context.request);
-    }
-    return next(context.request).then(response => {
-      return processResponse(response);
-    });
-  }
-};
+* MetaDocHandler processes requests that are marked as meta requests.
+*
+* It treats the response body as "entirely meta" transforming
+*
+* ```ts
+* {
+*   some: "key",
+*   another: "thing"
+* }
+* ```
+*
+* into
+*
+* ```ts
+* {
+* 	 meta: {
+*     some: "key",
+*     another: "thing"
+*   }
+* }
+* ```
+*
+* To activate this handler, a request should specify
+*
+* ```ts
+* options.isMetaRequest = true
+* ```
+*
+* For instance
+*
+* ```ts
+* store.request({
+*   url: '/example',
+*   options: {
+*     isMetaRequest: true
+*   }
+* });
+* ```
+*
+* Errors are not processed by this handler, so if the request fails and the error response
+* is not in {json:api} format additional processing may be needed.
+*
+* @group Handlers
+*/
+const MetaDocHandler = { request(context, next) {
+	if (!context.request.options?.isMetaRequest) return next(context.request);
+	return next(context.request).then((response) => {
+		return processResponse(response);
+	});
+} };
 function processResponse(response) {
-  return {
-    meta: response.content
-  };
+	return { meta: response.content };
 }
-if (typeof FastBoot === 'undefined') {
-  globalThis.addEventListener('beforeunload', function () {
-    sessionStorage.setItem('tab-closed', 'true');
-  });
-}
-function getTabId() {
-  if (typeof sessionStorage === 'undefined') {
-    return crypto.randomUUID();
-  }
-  const tabId = sessionStorage.getItem('tab-id');
-  if (tabId) {
-    const tabClosed = sessionStorage.getItem('tab-closed');
-    if (tabClosed === 'true') {
-      return tabId;
-    }
 
-    // fall through to generate a new tab id
-  }
-  const newTabId = crypto.randomUUID();
-  sessionStorage.setItem('tab-id', newTabId);
-  return newTabId;
+//#endregion
+//#region src/-private/handlers/utils.ts
+if (typeof FastBoot === "undefined") globalThis.addEventListener("beforeunload", function() {
+	sessionStorage.setItem("tab-closed", "true");
+});
+function getTabId() {
+	if (typeof sessionStorage === "undefined") return crypto.randomUUID();
+	const tabId = sessionStorage.getItem("tab-id");
+	if (tabId) {
+		if (sessionStorage.getItem("tab-closed") === "true") return tabId;
+	}
+	const newTabId = crypto.randomUUID();
+	sessionStorage.setItem("tab-id", newTabId);
+	return newTabId;
 }
-
 /**
- * A unique identifier for the current browser tab
- * useful for observability/tracing and deduping
- * across multiple tabs.
- *
- * @group Constants
- */
+* A unique identifier for the current browser tab
+* useful for observability/tracing and deduping
+* across multiple tabs.
+*
+* @group Constants
+*/
 const TAB_ID = getTabId();
 /**
- * The epoch seconds at which the tab id was generated
- *
- * @group Constants
- */
-const TAB_ASSIGNED = Math.floor(Date.now() / 1000);
-
+* The epoch seconds at which the tab id was generated
+*
+* @group Constants
+*/
+const TAB_ASSIGNED = Math.floor(Date.now() / 1e3);
 /**
- * Adds the `X-Amzn-Trace-Id` header to support observability
- * tooling around request routing.
- *
- * This makes use of the {@link TAB_ID} and {@link TAB_ASSIGNED}
- * to enable tracking the browser tab of origin across multiple requests.
- *
- * Follows the template: `Root=1-${now}-${uuidv4};TabId=1-${epochSeconds}-${tab-uuid}`
- *
- * @group Utility Functions
- */
+* Adds the `X-Amzn-Trace-Id` header to support observability
+* tooling around request routing.
+*
+* This makes use of the {@link TAB_ID} and {@link TAB_ASSIGNED}
+* to enable tracking the browser tab of origin across multiple requests.
+*
+* Follows the template: `Root=1-${now}-${uuidv4};TabId=1-${epochSeconds}-${tab-uuid}`
+*
+* @group Utility Functions
+*/
 function addTraceHeader(headers) {
-  const now = Math.floor(Date.now() / 1000);
-  headers.set('X-Amzn-Trace-Id', `Root=1-${now}-${crypto.randomUUID()};TabId=1-${TAB_ASSIGNED}-${TAB_ID}`);
-  return headers;
+	const now = Math.floor(Date.now() / 1e3);
+	headers.set("X-Amzn-Trace-Id", `Root=1-${now}-${crypto.randomUUID()};TabId=1-${TAB_ASSIGNED}-${TAB_ID}`);
+	return headers;
 }
-
 /**
- * Source: https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/cloudfront-limits.html
- * As of 2024-12-05 the maximum URL length is 8192 bytes.
- *
- * @group Constants
- */
+* Source: https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/cloudfront-limits.html
+* As of 2024-12-05 the maximum URL length is 8192 bytes.
+*
+* @group Constants
+*/
 const MAX_URL_LENGTH = 8192;
-
 /**
- * This assertion takes a URL and throws an error if the URL is longer than the maximum URL length.
- *
- * See also {@link MAX_URL_LENGTH}
- *
- * @group Utility Functions
- */
+* This assertion takes a URL and throws an error if the URL is longer than the maximum URL length.
+*
+* See also {@link MAX_URL_LENGTH}
+*
+* @group Utility Functions
+*/
 function assertInvalidUrlLength(url) {}
-export { AutoCompress, Gate, MAX_URL_LENGTH, MetaDocHandler, SupportsRequestStreams, TAB_ASSIGNED, TAB_ID, addTraceHeader, assertInvalidUrlLength };
+
+//#endregion
+export { AutoCompress, Gate, MAX_URL_LENGTH, MetaDocHandler, SupportsRequestStreams, TAB_ASSIGNED, TAB_ID, addTraceHeader, assertInvalidUrlLength };
+//# sourceMappingURL=handlers.js.map

package/dist/unpkg/prod-deprecated/handlers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handlers.js","names":["isCompressibleMethod","method","SupportsRequestStreams","duplexAccessed","hasContentType","Request","body","ReadableStream","duplex","headers","has","DEFAULT_CONSTRAINTS","Blob","ArrayBuffer","TypedArray","DataView","String","Object","getPrototypeOf","Uint8Array","AutoCompress","constructor","options","opts","format","constraints","assign","allowStreaming","forceStreaming","request","next","shouldCompress","compress","canCompress","length","size","byteLength","response","Response","stream","pipeThrough","CompressionStream","Headers","set","encodingForFormat","req","resp","blob","then","type","Gate","constructor","handler","checkFn","request","context","next","FastBoot","globalThis","addEventListener","sessionStorage","setItem","getTabId","crypto","randomUUID","tabId","getItem","tabClosed","newTabId","TAB_ID","TAB_ASSIGNED","Math","floor","Date","now","addTraceHeader","headers","set","MAX_URL_LENGTH","assertInvalidUrlLength","url"],"sources":["../../../src/-private/handlers/auto-compress.ts","../../../src/-private/handlers/gated.ts","../../../src/-private/handlers/meta-doc.ts","../../../src/-private/handlers/utils.ts"],"sourcesContent":["import { assert } from '@warp-drive/core/build-config/macros';\nimport type { Future, Handler, NextFn } from '@warp-drive/core/request';\nimport type { HTTPMethod, RequestContext } from '@warp-drive/core/types/request';\n\nfunction isCompressibleMethod(method?: HTTPMethod): boolean {\n  return method === 'POST' || method === 'PUT' || method === 'PATCH' || method === 'DELETE';\n}\n\n/**\n * Whether the browser supports `ReadableStream` as a request body\n * in a `POST` request.\n *\n * @group Constants\n */\nexport const SupportsRequestStreams: boolean = (() => {\n  let duplexAccessed = false;\n\n  const hasContentType = new Request('', {\n    body: new ReadableStream(),\n    method: 'POST',\n    // @ts-expect-error untyped\n    get duplex() {\n      duplexAccessed = true;\n      return 'half';\n    },\n  }).headers.has('Content-Type');\n\n  return duplexAccessed && !hasContentType;\n})();\n\ninterface Constraints {\n  /**\n   * The minimum size at which to compress blobs\n   *\n   * @default 1000\n   */\n  Blob?: number;\n  /**\n   * The minimum size at which to compress array buffers\n   *\n   * @default 1000\n   */\n  ArrayBuffer?: number;\n  /**\n   * The minimum size at which to compress typed arrays\n   *\n   * @default 1000\n   */\n  TypedArray?: number;\n  /**\n   * The minimum size at which to compress data views\n   *\n   * @default 1000\n   */\n  DataView?: number;\n  /**\n   * The minimum size at which to compress strings\n   *\n   * @default 1000\n   */\n  String?: number;\n}\n\n/**\n * Options for configuring the AutoCompress handler.\n *\n */\ninterface CompressionOptions {\n  /**\n   * The compression format to use. Must be a valid\n   * compression format supported by [CompressionStream](https://developer.mozilla.org/en-US/docs/Web/API/CompressionStream)\n   *\n   * The default is `gzip`.\n   *\n   */\n  format?: CompressionFormat;\n\n  /**\n   * Some browsers support `ReadableStream` as a request body. This option\n   * enables passing the compression stream as the request body instead of\n   * the final compressed body when the browser supports doing so.\n   *\n   * This comes with several caveats:\n   *\n   * - the request will be put into `duplex: 'half'` mode. This should be\n   *   transparent to you, but it is worth noting.\n   * - the request mode cannot be `no-cors` as requests with a `ReadableStream`\n   *   have no content length and thus are a new form of request that triggers\n   *   cors requirements and a preflight request.\n   * - http/1.x is not supported.\n   *\n   * For additional reading about the restrictions of using `ReadableStream`\n   * as a request body, see the [Chromium Documentation](https://developer.chrome.com/docs/capabilities/web-apis/fetch-streaming-requests#restrictions)\n   *\n   * Streaming can be enabled per-request in browsers which support it by\n   * setting `request.options.allowStreaming` to `true`.\n   *\n   * Streaming can be forced even when the browser does not support it by setting\n   * `request.options.forceStreaming` to `true`. This is useful if later handlers\n   * in the chain can handle the request body as a stream.\n   *\n   * @default false\n   */\n  allowStreaming?: boolean;\n\n  /**\n   * If `true`, the request will be forced into streaming mode even\n   * if the browser does not support it. This is useful if later handlers\n   * in the chain can handle the request body as a stream.\n   *\n   * @default false\n   */\n  forceStreaming?: boolean;\n\n  /**\n   * The constraints for the request body. This is used to determine\n   * whether to compress the request body or not.\n   *\n   * The defaults are:\n   *\n   * ```ts\n   * {\n   *   Blob: 1000, // blob.size\n   *   ArrayBuffer: 1000, // buffer.byteLength\n   *   TypedArray: 1000, // array.byteLength\n   *   DataView: 1000, // view.byteLength\n   *   String: 1000, // string.length\n   * }\n   * ```\n   *\n   * The following body types are never compressed unless explicitly\n   * configured by the request:\n   * - `FormData`\n   * - `URLSearchParams`\n   * - `ReadableStream`\n   *\n   * A request.options.compress value of `false` will disable\n   * compression for a request body of any type. While a value of\n   * `true` will enable compression for the request.\n   *\n   * An undefined value will use the default, a value of `0` will\n   * enable compression for all values, and a value of `-1` will\n   * disable compression.\n   *\n   */\n  constraints?: Constraints;\n}\n\nconst DEFAULT_CONSTRAINTS = {\n  Blob: 1000,\n  ArrayBuffer: 1000,\n  TypedArray: 1000,\n  DataView: 1000,\n  String: 1000,\n};\nconst TypedArray = Object.getPrototypeOf(Uint8Array) as typeof Uint8Array;\n\n/**\n * A request handler that automatically compresses the request body\n * if the request body is a string, array buffer, blob, or form data.\n *\n * This uses the [CompressionStream API](https://developer.mozilla.org/en-US/docs/Web/API/CompressionStream)\n *\n * The compression format as well as the kinds of data to compress can be\n * configured using the `format` and `constraints` options.\n *\n * ```diff\n * +import { AutoCompress } from '@ember-data/request-utils/handlers';\n * import Fetch from '@ember-data/request/fetch';\n * import RequestManager from '@ember-data/request';\n * import Store from '@ember-data/store';\n *\n * class AppStore extends Store {\n *   requestManager = new RequestManager()\n *     .use([\n * +       new AutoCompress(),\n *        Fetch\n *     ]);\n * }\n * ```\n *\n * @group Handlers\n * @public\n * @since 5.5.0\n */\nexport class AutoCompress implements Handler {\n  /**\n   * The resolved options this handler was configured with, with all\n   * defaults (including `constraints` defaults) applied.\n   */\n  declare options: Required<CompressionOptions> & {\n    /**\n     * The resolved size constraints used to decide whether to compress a given request body.\n     */\n    constraints: Required<Constraints>;\n  };\n\n  constructor(options: CompressionOptions = {}) {\n    const opts = {\n      format: options.format ?? 'gzip',\n      constraints: Object.assign({}, DEFAULT_CONSTRAINTS, options.constraints),\n      allowStreaming: options.allowStreaming ?? false,\n      forceStreaming: options.forceStreaming ?? false,\n    };\n    this.options = opts;\n  }\n\n  request<T>({ request }: RequestContext, next: NextFn<T>): Promise<T> | Future<T> {\n    const { constraints } = this.options;\n    const { body } = request;\n\n    const shouldCompress =\n      !!body &&\n      isCompressibleMethod(request.method) &&\n      request.options?.compress !== false &&\n      // prettier-ignore\n      (request.options?.compress ? true\n      : typeof body === 'string' || body instanceof String ? canCompress('String', constraints, body.length)\n      : body instanceof Blob ? canCompress('Blob', constraints, body.size)\n      : body instanceof ArrayBuffer ? canCompress('ArrayBuffer', constraints, body.byteLength)\n      : body instanceof DataView ? canCompress('DataView', constraints, body.byteLength)\n      : body instanceof TypedArray ? canCompress('TypedArray', constraints, body.byteLength)\n      : false);\n\n    if (!shouldCompress) return next(request);\n\n    // A convenient way to convert all of the supported body types to a readable\n    // stream is to use a `Response` object body\n    const response = new Response(request.body);\n    const stream = response.body?.pipeThrough(new CompressionStream(this.options.format));\n    const headers = new Headers(request.headers);\n    headers.set('Content-Encoding', encodingForFormat(this.options.format));\n\n    //\n    // For browsers that support it, `fetch` can receive a `ReadableStream` as\n    // the body, so all we need to do is to create a new `ReadableStream` and\n    // compress it on the fly\n    //\n    const forceStreaming = request.options?.forceStreaming ?? this.options.forceStreaming;\n    const allowStreaming = request.options?.allowStreaming ?? this.options.allowStreaming;\n    if (forceStreaming || (SupportsRequestStreams && allowStreaming)) {\n      const req = Object.assign({}, request, {\n        body: stream,\n        headers,\n      });\n      if (SupportsRequestStreams) {\n        // @ts-expect-error untyped\n        req.duplex = 'half';\n      }\n\n      return next(req);\n\n      //\n      // For non-chromium browsers, we have to \"pull\" the stream to get the final\n      // bytes and supply the final byte array as the new request body.\n      //\n    }\n\n    // we need to pull the stream to get the final bytes\n    const resp = new Response(stream);\n    return resp.blob().then((blob) => {\n      const req = Object.assign({}, request, {\n        body: blob,\n        headers,\n      });\n      return next(req);\n    }) as Promise<T>;\n  }\n}\n\nfunction canCompress(type: keyof Constraints, constraints: Required<Constraints>, size: number): boolean {\n  // if we have a value of 0, we can compress anything\n  if (constraints[type] === 0) return true;\n  if (constraints[type] === -1) return false;\n  return size >= constraints[type];\n}\n\nfunction encodingForFormat(format: CompressionFormat): string {\n  switch (format) {\n    case 'gzip':\n    case 'deflate':\n    case 'deflate-raw':\n      return format;\n    default:\n      assert(`Unsupported compression format: ${format as unknown as string}`);\n      // @ts-expect-error - unreachable code is reachable in production\n      return format;\n  }\n}\n","import type { Future, Handler, NextFn } from '@warp-drive/core/request';\nimport type { RequestContext, StructuredDataDocument } from '@warp-drive/core/types/request';\n\n/**\n * If CheckFn returns true, the wrapped handler will be used.\n * If CheckFn returns false, the wrapped handler will be skipped.\n */\ntype CheckFn = (context: RequestContext) => boolean;\n\n/**\n *\n * @group Handlers\n * @public\n */\nexport class Gate implements Handler {\n  /**\n   * The wrapped handler to invoke when {@link Gate.checkFn | checkFn} returns `true`.\n   */\n  declare handler: Handler;\n  /**\n   * The predicate used to decide whether {@link Gate.handler | handler} should run for a given request.\n   */\n  declare checkFn: CheckFn;\n\n  constructor(handler: Handler, checkFn: CheckFn) {\n    this.handler = handler;\n    this.checkFn = checkFn;\n  }\n\n  request<T = unknown>(context: RequestContext, next: NextFn<T>): Promise<T | StructuredDataDocument<T>> | Future<T> {\n    if (this.checkFn(context)) {\n      return this.handler.request(context, next);\n    }\n    return next(context.request);\n  }\n}\n","import type { StoreRequestContext } from '@warp-drive/core';\nimport type { Handler, NextFn } from '@warp-drive/core/request';\nimport type { StructuredDataDocument } from '@warp-drive/core/types/request';\n\n/**\n * MetaDocHandler processes requests that are marked as meta requests.\n *\n * It treats the response body as \"entirely meta\" transforming\n *\n * ```ts\n * {\n *   some: \"key\",\n *   another: \"thing\"\n * }\n * ```\n *\n * into\n *\n * ```ts\n * {\n * \t meta: {\n *     some: \"key\",\n *     another: \"thing\"\n *   }\n * }\n * ```\n *\n * To activate this handler, a request should specify\n *\n * ```ts\n * options.isMetaRequest = true\n * ```\n *\n * For instance\n *\n * ```ts\n * store.request({\n *   url: '/example',\n *   options: {\n *     isMetaRequest: true\n *   }\n * });\n * ```\n *\n * Errors are not processed by this handler, so if the request fails and the error response\n * is not in {json:api} format additional processing may be needed.\n *\n * @group Handlers\n */\nexport const MetaDocHandler: Handler = {\n  request<T>(context: StoreRequestContext, next: NextFn<T>): Promise<T | StructuredDataDocument<T> | Awaited<T>> {\n    if (!context.request.options?.isMetaRequest) {\n      return next(context.request);\n    }\n\n    return next(context.request).then((response) => {\n      return processResponse<T>(response);\n    });\n  },\n};\n\nfunction processResponse<T>(response: StructuredDataDocument<T>): T {\n  return {\n    meta: response.content,\n  } as T;\n}\n","import { assert } from '@warp-drive/core/build-config/macros';\n\nif (typeof FastBoot === 'undefined') {\n  globalThis.addEventListener('beforeunload', function () {\n    sessionStorage.setItem('tab-closed', 'true');\n  });\n}\n\nfunction getTabId() {\n  if (typeof sessionStorage === 'undefined') {\n    return crypto.randomUUID();\n  }\n\n  const tabId = sessionStorage.getItem('tab-id');\n  if (tabId) {\n    const tabClosed = sessionStorage.getItem('tab-closed');\n    if (tabClosed === 'true') {\n      return tabId;\n    }\n\n    // fall through to generate a new tab id\n  }\n\n  const newTabId = crypto.randomUUID();\n  sessionStorage.setItem('tab-id', newTabId);\n  return newTabId;\n}\n\n/**\n * A unique identifier for the current browser tab\n * useful for observability/tracing and deduping\n * across multiple tabs.\n *\n * @group Constants\n */\nexport const TAB_ID: string = getTabId();\n/**\n * The epoch seconds at which the tab id was generated\n *\n * @group Constants\n */\nexport const TAB_ASSIGNED: number = Math.floor(Date.now() / 1000);\n\n/**\n * Adds the `X-Amzn-Trace-Id` header to support observability\n * tooling around request routing.\n *\n * This makes use of the {@link TAB_ID} and {@link TAB_ASSIGNED}\n * to enable tracking the browser tab of origin across multiple requests.\n *\n * Follows the template: `Root=1-${now}-${uuidv4};TabId=1-${epochSeconds}-${tab-uuid}`\n *\n * @group Utility Functions\n */\nexport function addTraceHeader(headers: Headers): Headers {\n  const now = Math.floor(Date.now() / 1000);\n  headers.set('X-Amzn-Trace-Id', `Root=1-${now}-${crypto.randomUUID()};TabId=1-${TAB_ASSIGNED}-${TAB_ID}`);\n\n  return headers;\n}\n\n/**\n * Source: https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/cloudfront-limits.html\n * As of 2024-12-05 the maximum URL length is 8192 bytes.\n *\n * @group Constants\n */\nexport const MAX_URL_LENGTH = 8192;\n\n/**\n * This assertion takes a URL and throws an error if the URL is longer than the maximum URL length.\n *\n * See also {@link MAX_URL_LENGTH}\n *\n * @group Utility Functions\n */\nexport function assertInvalidUrlLength(url: string | undefined): void {\n  assert(\n    `URL length ${url?.length} exceeds the maximum URL length of ${MAX_URL_LENGTH} bytes.\\n\\nConsider converting this request query a \\`/query\\` endpoint instead of a GET, or upgrade the current endpoint to be able to receive a POST request directly (ideally specifying the header HTTP-Method-Override: QUERY)\\n\\nThe Invalid URL is:\\n\\n${url}`,\n    !url || url.length <= MAX_URL_LENGTH\n  );\n}\n"],"mappings":"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"}