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

package/declarations/active-record.d.ts

@@ -1,3 +1,260 @@
-export { findRecord } from "./-private/active-record/find-record.js";
-export { query } from "./-private/active-record/query.js";
-export { deleteRecord, createRecord, updateRecord } from "./-private/active-record/save-record.js";
+import { ReactiveDataDocument } from "@warp-drive-mirror/core/reactive";
+import { TypeFromInstance, TypedRecordInstance } from "@warp-drive-mirror/core/types/record";
+import { ConstrainedRequestOptions, CreateRequestOptions, DeleteRequestOptions, FindRecordOptions, FindRecordRequestOptions, QueryRequestOptions, RemotelyAccessibleIdentifier, UpdateRequestOptions } from "@warp-drive-mirror/core/types/request";
+import { QueryParamsSource } from "@warp-drive-mirror/core/types/params";
+//#region src/-private/active-record/find-record.d.ts
+/**
+ * Builds request options to fetch a single resource by a known id or identifier
+ * configured for the url and header expectations of most ActiveRecord APIs.
+ *
+ * **Basic Usage**
+ *
+ * ```ts
+ * import { findRecord } from '@warp-drive-mirror/utilities/active-record';
+ *
+ * const data = await store.request(findRecord('person', '1'));
+ * ```
+ *
+ * **With Options**
+ *
+ * ```ts
+ * import { findRecord } from '@warp-drive-mirror/utilities/active-record';
+ *
+ * const options = findRecord('person', '1', { include: ['pets', 'friends'] });
+ * const data = await store.request(options);
+ * ```
+ *
+ * **With an Identifier**
+ *
+ * ```ts
+ * import { findRecord } from '@warp-drive-mirror/utilities/active-record';
+ *
+ * const options = findRecord({ type: 'person', id: '1' }, { include: ['pets', 'friends'] });
+ * const data = await store.request(options);
+ * ```
+ *
+ * **Supplying Options to Modify the Request Behavior**
+ *
+ * The following options are supported:
+ *
+ * - `host` - The host to use for the request, defaults to the `host` configured with `setBuildURLConfig`.
+ * - `namespace` - The namespace to use for the request, defaults to the `namespace` configured with `setBuildURLConfig`.
+ * - `resourcePath` - The resource path to use for the request, defaults to pluralizing and underscoring the supplied type
+ * - `reload` - Whether to forcibly reload the request if it is already in the store, not supplying this
+ *      option will delegate to the store's CachePolicy, defaulting to `false` if none is configured.
+ * - `backgroundReload` - Whether to reload the request if it is already in the store, but to also resolve the
+ *      promise with the cached value, not supplying this option will delegate to the store's CachePolicy,
+ *      defaulting to `false` if none is configured.
+ * - `urlParamsSetting` - an object containing options for how to serialize the query params (see `buildQueryParams`)
+ *
+ * ```ts
+ * import { findRecord } from '@warp-drive-mirror/utilities/active-record';
+ *
+ * const options = findRecord('person', '1', { include: ['pets', 'friends'] }, { namespace: 'api/v2' });
+ * const data = await store.request(options);
+ * ```
+ *
+ * @public
+ * @param identifier
+ * @param options
+ */
+declare function findRecord<T>(identifier: RemotelyAccessibleIdentifier<TypeFromInstance<T>>, options?: FindRecordOptions): FindRecordRequestOptions<ReactiveDataDocument<T>, T>;
+declare function findRecord(identifier: RemotelyAccessibleIdentifier, options?: FindRecordOptions): FindRecordRequestOptions;
+declare function findRecord<T>(type: TypeFromInstance<T>, id: string, options?: FindRecordOptions): FindRecordRequestOptions<ReactiveDataDocument<T>, T>;
+declare function findRecord(type: string, id: string, options?: FindRecordOptions): FindRecordRequestOptions;
+//#endregion
+//#region src/-private/active-record/query.d.ts
+/**
+ * Builds request options to query for resources, usually by a primary
+ * type, configured for the url and header expectations of most ActiveRecord APIs.
+ *
+ * **Basic Usage**
+ *
+ * ```ts
+ * import { query } from '@warp-drive-mirror/utilities/active-record';
+ *
+ * const data = await store.request(query('person'));
+ * ```
+ *
+ * **With Query Params**
+ *
+ * ```ts
+ * import { query } from '@warp-drive-mirror/utilities/active-record';
+ *
+ * const options = query('person', { include: ['pets', 'friends'] });
+ * const data = await store.request(options);
+ * ```
+ *
+ * **Supplying Options to Modify the Request Behavior**
+ *
+ * The following options are supported:
+ *
+ * - `host` - The host to use for the request, defaults to the `host` configured with `setBuildURLConfig`.
+ * - `namespace` - The namespace to use for the request, defaults to the `namespace` configured with `setBuildURLConfig`.
+ * - `resourcePath` - The resource path to use for the request, defaults to pluralizing and underscoring the supplied type
+ * - `reload` - Whether to forcibly reload the request if it is already in the store, not supplying this
+ *      option will delegate to the store's CachePolicy, defaulting to `false` if none is configured.
+ * - `backgroundReload` - Whether to reload the request if it is already in the store, but to also resolve the
+ *      promise with the cached value, not supplying this option will delegate to the store's CachePolicy,
+ *      defaulting to `false` if none is configured.
+ * - `urlParamsSetting` - an object containing options for how to serialize the query params (see `buildQueryParams`)
+ *
+ * ```ts
+ * import { query } from '@warp-drive-mirror/utilities/active-record';
+ *
+ * const options = query('person', { include: ['pets', 'friends'] }, { reload: true });
+ * const data = await store.request(options);
+ * ```
+ *
+ * @public
+ * @param identifier
+ * @param query
+ * @param options
+ */
+declare function query<T>(type: TypeFromInstance<T>, query?: QueryParamsSource, options?: ConstrainedRequestOptions): QueryRequestOptions<ReactiveDataDocument<T[]>>;
+declare function query(type: string, query?: QueryParamsSource, options?: ConstrainedRequestOptions): QueryRequestOptions;
+//#endregion
+//#region src/-private/active-record/save-record.d.ts
+/**
+ * Builds request options to delete record for resources,
+ * configured for the url, method and header expectations of ActiveRecord APIs.
+ *
+ * **Basic Usage**
+ *
+ * ```ts
+ * import { deleteRecord } from '@warp-drive-mirror/utilities/active-record';
+ *
+ * const person = store.peekRecord('person', '1');
+ *
+ * // mark record as deleted
+ * store.deleteRecord(person);
+ *
+ * // persist deletion
+ * const data = await store.request(deleteRecord(person));
+ * ```
+ *
+ * **Supplying Options to Modify the Request Behavior**
+ *
+ * The following options are supported:
+ *
+ * - `host` - The host to use for the request, defaults to the `host` configured with `setBuildURLConfig`.
+ * - `namespace` - The namespace to use for the request, defaults to the `namespace` configured with `setBuildURLConfig`.
+ * - `resourcePath` - The resource path to use for the request, defaults to pluralizing the supplied type
+ * - `reload` - Whether to forcibly reload the request if it is already in the store, not supplying this
+ *      option will delegate to the store's CachePolicy, defaulting to `false` if none is configured.
+ * - `backgroundReload` - Whether to reload the request if it is already in the store, but to also resolve the
+ *      promise with the cached value, not supplying this option will delegate to the store's CachePolicy,
+ *      defaulting to `false` if none is configured.
+ * - `urlParamsSetting` - an object containing options for how to serialize the query params (see `buildQueryParams`)
+ *
+ * ```ts
+ * import { deleteRecord } from '@warp-drive-mirror/utilities/active-record';
+ *
+ * const person = store.peekRecord('person', '1');
+ *
+ * // mark record as deleted
+ * store.deleteRecord(person);
+ *
+ * // persist deletion
+ * const options = deleteRecord(person, { namespace: 'api/v1' });
+ * const data = await store.request(options);
+ * ```
+ *
+ * @public
+ * @param record
+ * @param options
+ */
+declare function deleteRecord<T>(record: T, options?: ConstrainedRequestOptions): DeleteRequestOptions<T>;
+declare function deleteRecord(record: unknown, options?: ConstrainedRequestOptions): DeleteRequestOptions;
+/**
+ * Builds request options to create new record for resources,
+ * configured for the url, method and header expectations of most ActiveRecord APIs.
+ *
+ * **Basic Usage**
+ *
+ * ```ts
+ * import { createRecord } from '@warp-drive-mirror/utilities/active-record';
+ *
+ * const person = store.createRecord('person', { name: 'Ted' });
+ * const data = await store.request(createRecord(person));
+ * ```
+ *
+ * **Supplying Options to Modify the Request Behavior**
+ *
+ * The following options are supported:
+ *
+ * - `host` - The host to use for the request, defaults to the `host` configured with `setBuildURLConfig`.
+ * - `namespace` - The namespace to use for the request, defaults to the `namespace` configured with `setBuildURLConfig`.
+ * - `resourcePath` - The resource path to use for the request, defaults to pluralizing the supplied type
+ * - `reload` - Whether to forcibly reload the request if it is already in the store, not supplying this
+ *      option will delegate to the store's CachePolicy, defaulting to `false` if none is configured.
+ * - `backgroundReload` - Whether to reload the request if it is already in the store, but to also resolve the
+ *      promise with the cached value, not supplying this option will delegate to the store's CachePolicy,
+ *      defaulting to `false` if none is configured.
+ * - `urlParamsSetting` - an object containing options for how to serialize the query params (see `buildQueryParams`)
+ *
+ * ```ts
+ * import { createRecord } from '@warp-drive-mirror/utilities/active-record';
+ *
+ * const person = store.createRecord('person', { name: 'Ted' });
+ * const options = createRecord(person, { namespace: 'api/v1' });
+ * const data = await store.request(options);
+ * ```
+ *
+ * @public
+ * @param record
+ * @param options
+ */
+declare function createRecord<T>(record: T, options?: ConstrainedRequestOptions): CreateRequestOptions<T>;
+declare function createRecord(record: unknown, options?: ConstrainedRequestOptions): CreateRequestOptions;
+/**
+ * Builds request options to update existing record for resources,
+ * configured for the url, method and header expectations of most ActiveRecord APIs.
+ *
+ * **Basic Usage**
+ *
+ * ```ts
+ * import { updateRecord } from '@warp-drive-mirror/utilities/active-record';
+ *
+ * const person = store.peekRecord('person', '1');
+ * person.name = 'Chris';
+ * const data = await store.request(updateRecord(person));
+ * ```
+ *
+ * **Supplying Options to Modify the Request Behavior**
+ *
+ * The following options are supported:
+ *
+ * - `patch` - Allows caller to specify whether to use a PATCH request instead of a PUT request, defaults to `false`.
+ * - `host` - The host to use for the request, defaults to the `host` configured with `setBuildURLConfig`.
+ * - `namespace` - The namespace to use for the request, defaults to the `namespace` configured with `setBuildURLConfig`.
+ * - `resourcePath` - The resource path to use for the request, defaults to pluralizing the supplied type
+ * - `reload` - Whether to forcibly reload the request if it is already in the store, not supplying this
+ *      option will delegate to the store's CachePolicy, defaulting to `false` if none is configured.
+ * - `backgroundReload` - Whether to reload the request if it is already in the store, but to also resolve the
+ *      promise with the cached value, not supplying this option will delegate to the store's CachePolicy,
+ *      defaulting to `false` if none is configured.
+ * - `urlParamsSetting` - an object containing options for how to serialize the query params (see `buildQueryParams`)
+ *
+ * ```ts
+ * import { updateRecord } from '@warp-drive-mirror/utilities/active-record';
+ *
+ * const person = store.peekRecord('person', '1');
+ * person.name = 'Chris';
+ * const options = updateRecord(person, { patch: true });
+ * const data = await store.request(options);
+ * ```
+ *
+ * @public
+ * @param record
+ * @param options
+ */
+declare function updateRecord<T extends TypedRecordInstance, RT extends TypedRecordInstance = T>(record: T, options?: ConstrainedRequestOptions & {
+  patch?: boolean;
+}): UpdateRequestOptions<ReactiveDataDocument<RT>, T>;
+declare function updateRecord(record: unknown, options?: ConstrainedRequestOptions & {
+  patch?: boolean;
+}): UpdateRequestOptions;
+//#endregion
+export { createRecord, deleteRecord, findRecord, query, updateRecord };
+//# sourceMappingURL=active-record.d.ts.map

package/declarations/active-record.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"active-record.d.ts","names":[],"sources":["../src/-private/active-record/find-record.ts","../src/-private/active-record/query.ts","../src/-private/active-record/save-record.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmEgB,WAAW,GACzB,YAAY,6BAA6B,iBAAiB,KAC1D,UAAU,oBACT,yBAAyB,qBAAqB,IAAI;iBACrC,WACd,YAAY,8BACZ,UAAU,oBACT;iBACa,WAAW,GACzB,MAAM,iBAAiB,IACvB,YACA,UAAU,oBACT,yBAAyB,qBAAqB,IAAI;iBACrC,WAAW,cAAc,YAAY,UAAU,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBCxBnE,MAAM,GACpB,MAAM,iBAAiB,IACvB,QAAQ,mBACR,UAAU,4BACT,oBAAoB,qBAAqB;iBAC5B,MACd,cACA,QAAQ,mBACR,UAAU,4BACT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBCSa,aAAa,GAAG,QAAQ,GAAG,UAAU,4BAA4B,qBAAqB;iBACtF,aAAa,iBAAiB,UAAU,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqEpE,aAAa,GAAG,QAAQ,GAAG,UAAU,4BAA4B,qBAAqB;iBACtF,aAAa,iBAAiB,UAAU,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuEpE,aAAa,UAAU,qBAAqB,WAAW,sBAAsB,GAC3F,QAAQ,GACR,UAAU;EAA8B;IACvC,qBAAqB,qBAAqB,KAAK;iBAClC,aACd,iBACA,UAAU;EAA8B;IACvC"}

package/declarations/derivations.d.ts

@@ -1,27 +1,30 @@
-import type { ReactiveResource } from "@warp-drive-mirror/core/reactive";
 import { Type } from "@warp-drive-mirror/core/types/symbols";
+import { ReactiveResource } from "@warp-drive-mirror/core/reactive";
+//#region src/derivations.d.ts
 interface ConcatDerivation {
-	(record: ReactiveResource & {
-		[key: string]: unknown;
-	}, options: Record<string, unknown> | null, _prop: string): string;
-	[Type]: "concat";
+  (record: ReactiveResource & {
+    [key: string]: unknown;
+  }, options: Record<string, unknown> | null, _prop: string): string;
+  [Type]: "concat";
 }
 /**
-* A derivation for use by {@link ReactiveResource} that joins the given fields
-* with the optional separator (or '' if no separator is provided).
-*
-* Generally you should not need to import and use this function directly.
-*
-* @example
-* {
-*   name: 'fullName',
-*   kind: 'derived',
-*   type: 'concat',
-*   options: {
-*     fields: ['firstName', 'lastName'],
-*     separator: ' ',
-*   },
-* }
-*/
-export declare const concat: ConcatDerivation;
-export {};
+ * A derivation for use by {@link ReactiveResource} that joins the given fields
+ * with the optional separator (or '' if no separator is provided).
+ *
+ * Generally you should not need to import and use this function directly.
+ *
+ * @example
+ * {
+ *   name: 'fullName',
+ *   kind: 'derived',
+ *   type: 'concat',
+ *   options: {
+ *     fields: ['firstName', 'lastName'],
+ *     separator: ' ',
+ *   },
+ * }
+ */
+declare const concat: ConcatDerivation;
+//#endregion
+export { concat };
+//# sourceMappingURL=derivations.d.ts.map

package/declarations/derivations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"derivations.d.ts","names":[],"sources":["../src/derivations.ts"],"mappings":";;;UAGU;GAEN,QAAQ;;KACR,SAAS,gCACT;GAED;;;;;;;;;;;;;;;;;;;cAoBU,QAAQ"}

package/declarations/handlers.d.ts

@@ -1,10 +1,283 @@
+import { RequestContext, StructuredDataDocument } from "@warp-drive-mirror/core/types/request";
+import { Future, Handler, NextFn } from "@warp-drive-mirror/core/request";
+//#region src/-private/handlers/auto-compress.d.ts
 /**
-* A selection of pre-built request handlers for handling common
-* request scenarios.
-*
-* @module
-*/
-export { AutoCompress, SupportsRequestStreams } from "./-private/handlers/auto-compress.js";
-export { Gate } from "./-private/handlers/gated.js";
-export { MetaDocHandler } from "./-private/handlers/meta-doc.js";
-export { addTraceHeader, TAB_ASSIGNED, TAB_ID, assertInvalidUrlLength, MAX_URL_LENGTH } from "./-private/handlers/utils.js";
+ * Whether the browser supports `ReadableStream` as a request body
+ * in a `POST` request.
+ *
+ * @group Constants
+ */
+declare const SupportsRequestStreams: boolean;
+interface Constraints {
+  /**
+   * The minimum size at which to compress blobs
+   *
+   * @default 1000
+   */
+  Blob?: number;
+  /**
+   * The minimum size at which to compress array buffers
+   *
+   * @default 1000
+   */
+  ArrayBuffer?: number;
+  /**
+   * The minimum size at which to compress typed arrays
+   *
+   * @default 1000
+   */
+  TypedArray?: number;
+  /**
+   * The minimum size at which to compress data views
+   *
+   * @default 1000
+   */
+  DataView?: number;
+  /**
+   * The minimum size at which to compress strings
+   *
+   * @default 1000
+   */
+  String?: number;
+}
+/**
+ * Options for configuring the AutoCompress handler.
+ *
+ */
+interface CompressionOptions {
+  /**
+   * The compression format to use. Must be a valid
+   * compression format supported by [CompressionStream](https://developer.mozilla.org/en-US/docs/Web/API/CompressionStream)
+   *
+   * The default is `gzip`.
+   *
+   */
+  format?: CompressionFormat;
+  /**
+   * Some browsers support `ReadableStream` as a request body. This option
+   * enables passing the compression stream as the request body instead of
+   * the final compressed body when the browser supports doing so.
+   *
+   * This comes with several caveats:
+   *
+   * - the request will be put into `duplex: 'half'` mode. This should be
+   *   transparent to you, but it is worth noting.
+   * - the request mode cannot be `no-cors` as requests with a `ReadableStream`
+   *   have no content length and thus are a new form of request that triggers
+   *   cors requirements and a preflight request.
+   * - http/1.x is not supported.
+   *
+   * For additional reading about the restrictions of using `ReadableStream`
+   * as a request body, see the [Chromium Documentation](https://developer.chrome.com/docs/capabilities/web-apis/fetch-streaming-requests#restrictions)
+   *
+   * Streaming can be enabled per-request in browsers which support it by
+   * setting `request.options.allowStreaming` to `true`.
+   *
+   * Streaming can be forced even when the browser does not support it by setting
+   * `request.options.forceStreaming` to `true`. This is useful if later handlers
+   * in the chain can handle the request body as a stream.
+   *
+   * @default false
+   */
+  allowStreaming?: boolean;
+  /**
+   * If `true`, the request will be forced into streaming mode even
+   * if the browser does not support it. This is useful if later handlers
+   * in the chain can handle the request body as a stream.
+   *
+   * @default false
+   */
+  forceStreaming?: boolean;
+  /**
+   * The constraints for the request body. This is used to determine
+   * whether to compress the request body or not.
+   *
+   * The defaults are:
+   *
+   * ```ts
+   * {
+   *   Blob: 1000, // blob.size
+   *   ArrayBuffer: 1000, // buffer.byteLength
+   *   TypedArray: 1000, // array.byteLength
+   *   DataView: 1000, // view.byteLength
+   *   String: 1000, // string.length
+   * }
+   * ```
+   *
+   * The following body types are never compressed unless explicitly
+   * configured by the request:
+   * - `FormData`
+   * - `URLSearchParams`
+   * - `ReadableStream`
+   *
+   * A request.options.compress value of `false` will disable
+   * compression for a request body of any type. While a value of
+   * `true` will enable compression for the request.
+   *
+   * An undefined value will use the default, a value of `0` will
+   * enable compression for all values, and a value of `-1` will
+   * disable compression.
+   *
+   */
+  constraints?: Constraints;
+}
+/**
+ * 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-mirror/request-utils/handlers';
+ * import Fetch from '@ember-data-mirror/request/fetch';
+ * import RequestManager from '@ember-data-mirror/request';
+ * import Store from '@ember-data-mirror/store';
+ *
+ * class AppStore extends Store {
+ *   requestManager = new RequestManager()
+ *     .use([
+ * +       new AutoCompress(),
+ *        Fetch
+ *     ]);
+ * }
+ * ```
+ *
+ * @group Handlers
+ * @public
+ * @since 5.5.0
+ */
+declare class AutoCompress implements Handler {
+  /**
+   * The resolved options this handler was configured with, with all
+   * defaults (including `constraints` defaults) applied.
+   */
+  options: Required<CompressionOptions> & {
+    /**
+     * The resolved size constraints used to decide whether to compress a given request body.
+     */
+    constraints: Required<Constraints>;
+  };
+  constructor(options?: CompressionOptions);
+  request<T>({ request }: RequestContext, next: NextFn<T>): Promise<T> | Future<T>;
+}
+//#endregion
+//#region src/-private/handlers/gated.d.ts
+/**
+ * If CheckFn returns true, the wrapped handler will be used.
+ * If CheckFn returns false, the wrapped handler will be skipped.
+ */
+type CheckFn = (context: RequestContext) => boolean;
+/**
+ *
+ * @group Handlers
+ * @public
+ */
+declare class Gate implements Handler {
+  /**
+   * The wrapped handler to invoke when {@link Gate.checkFn | checkFn} returns `true`.
+   */
+  handler: Handler;
+  /**
+   * The predicate used to decide whether {@link Gate.handler | handler} should run for a given request.
+   */
+  checkFn: CheckFn;
+  constructor(handler: Handler, checkFn: CheckFn);
+  request<T = unknown>(context: RequestContext, next: NextFn<T>): Promise<T | StructuredDataDocument<T>> | Future<T>;
+}
+//#endregion
+//#region src/-private/handlers/meta-doc.d.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
+ */
+declare const MetaDocHandler: Handler;
+//#endregion
+//#region src/-private/handlers/utils.d.ts
+/**
+ * A unique identifier for the current browser tab
+ * useful for observability/tracing and deduping
+ * across multiple tabs.
+ *
+ * @group Constants
+ */
+declare const TAB_ID: string;
+/**
+ * The epoch seconds at which the tab id was generated
+ *
+ * @group Constants
+ */
+declare const TAB_ASSIGNED: number;
+/**
+ * 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
+ */
+declare function addTraceHeader(headers: Headers): 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
+ */
+declare 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
+ */
+declare function assertInvalidUrlLength(url: string | undefined): void;
+//#endregion
+export { AutoCompress, Gate, MAX_URL_LENGTH, MetaDocHandler, SupportsRequestStreams, TAB_ASSIGNED, TAB_ID, addTraceHeader, assertInvalidUrlLength };
+//# sourceMappingURL=handlers.d.ts.map

package/declarations/handlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handlers.d.ts","names":[],"sources":["../src/-private/handlers/auto-compress.ts","../src/-private/handlers/gated.ts","../src/-private/handlers/meta-doc.ts","../src/-private/handlers/utils.ts"],"mappings":";;;;;;;;;cAca;UAgBH;;;;;;EAMR;;;;;;EAMA;;;;;;EAMA;;;;;;EAMA;;;;;;EAMA;;;;;;UAOQ;;;;;;;;EAQR,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BT;;;;;;;;EASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiCA,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAwCH,wBAAwB;;;;;EAKnC,SAAiB,SAAS;;;;IAIxB,aAAa,SAAS;;EAGxB,YAAY,UAAS;EAUrB,QAAQ,KAAK,WAAW,gBAAgB,MAAM,OAAO,KAAK,QAAQ,KAAK,OAAO;;;;;;;;KCxM3E,WAAW,SAAS;;;;;;cAOZ,gBAAgB;;;;EAI3B,SAAiB;;;;EAIjB,SAAiB;EAEjB,YAAY,SAAS,SAAS,SAAS;EAKvC,QAAQ,aAAa,SAAS,gBAAgB,MAAM,OAAO,KAAK,QAAQ,IAAI,uBAAuB,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cCoBrG,gBAAgB;;;;;;;;;;cCdhB;;;;;;cAMA;;;;;;;;;;;;iBAaG,eAAe,SAAS,UAAU;;;;;;;cAarC;;;;;;;;iBASG,uBAAuB"}