@warp-drive/utilities 5.9.0-beta.0 → 5.9.0-beta.2

package/dist/unpkg/prod/builder-utils-BkXwUT0x.js

@@ -0,0 +1,16 @@
+//#region src/-private/builder-utils.ts
+function copyForwardUrlOptions(urlOptions, options) {
+	if ("host" in options) urlOptions.host = options.host;
+	if ("namespace" in options) urlOptions.namespace = options.namespace;
+	if ("resourcePath" in options) urlOptions.resourcePath = options.resourcePath;
+}
+function extractCacheOptions(options) {
+	const cacheOptions = {};
+	if ("reload" in options) cacheOptions.reload = options.reload;
+	if ("backgroundReload" in options) cacheOptions.backgroundReload = options.backgroundReload;
+	return cacheOptions;
+}
+
+//#endregion
+export { extractCacheOptions as n, copyForwardUrlOptions as t };
+//# sourceMappingURL=builder-utils-BkXwUT0x.js.map

package/dist/unpkg/prod/builder-utils-BkXwUT0x.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"builder-utils-BkXwUT0x.js","names":[],"sources":["../../../src/-private/builder-utils.ts"],"sourcesContent":["import type { CacheOptions, ConstrainedRequestOptions } from '@warp-drive/core/types/request';\n\nimport type { UrlOptions } from '../index.ts';\n\nexport function copyForwardUrlOptions(urlOptions: UrlOptions, options: ConstrainedRequestOptions): void {\n  if ('host' in options) {\n    urlOptions.host = options.host;\n  }\n  if ('namespace' in options) {\n    urlOptions.namespace = options.namespace;\n  }\n  if ('resourcePath' in options) {\n    urlOptions.resourcePath = options.resourcePath;\n  }\n}\n\nexport function extractCacheOptions(options: ConstrainedRequestOptions): CacheOptions {\n  const cacheOptions: CacheOptions = {};\n  if ('reload' in options) {\n    cacheOptions.reload = options.reload;\n  }\n  if ('backgroundReload' in options) {\n    cacheOptions.backgroundReload = options.backgroundReload;\n  }\n  return cacheOptions;\n}\n"],"mappings":";AAIA,SAAgB,sBAAsB,YAAwB,SAA0C;CACtG,IAAI,UAAU,SACZ,WAAW,OAAO,QAAQ;CAE5B,IAAI,eAAe,SACjB,WAAW,YAAY,QAAQ;CAEjC,IAAI,kBAAkB,SACpB,WAAW,eAAe,QAAQ;AAEtC;AAEA,SAAgB,oBAAoB,SAAkD;CACpF,MAAM,eAA6B,CAAC;CACpC,IAAI,YAAY,SACd,aAAa,SAAS,QAAQ;CAEhC,IAAI,sBAAsB,SACxB,aAAa,mBAAmB,QAAQ;CAE1C,OAAO;AACT"}

package/dist/unpkg/prod/derivations.js

@@ -1,30 +1,30 @@
-import { Type } from '@warp-drive/core/types/symbols';
+import { Type } from "@warp-drive/core/types/symbols";
 
+//#region src/derivations.ts
 /**
- * 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: ' ',
- *   },
- * }
- */
+* 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: ' ',
+*   },
+* }
+*/
 const concat = (record, options, _prop) => {
-  if (!options) {
-    throw new Error(`options is required`);
-  }
-  // SAFETY: we cast internally to a more specific type, for our own use
-  // SAFETY: but provide the more general signature to the schema service
-  const opts = options;
-  return opts.fields.map(field => record[field]).join(opts.separator ?? '');
+	if (!options) throw new Error(`options is required`);
+	const opts = options;
+	return opts.fields.map((field) => record[field]).join(opts.separator ?? "");
 };
-concat[Type] = 'concat';
-export { concat };
+concat[Type] = "concat";
+
+//#endregion
+export { concat };
+//# sourceMappingURL=derivations.js.map

package/dist/unpkg/prod/derivations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"derivations.js","names":["Type","concat","record","options","_prop","Error","opts","fields","map","field","join","separator"],"sources":["../../../src/derivations.ts"],"sourcesContent":["import type { ReactiveResource } from '@warp-drive/core/reactive';\nimport { Type } from '@warp-drive/core/types/symbols';\n\ninterface ConcatDerivation {\n  (\n    record: ReactiveResource & { [key: string]: unknown },\n    options: Record<string, unknown> | null,\n    _prop: string\n  ): string;\n  [Type]: 'concat';\n}\n\n/**\n * A derivation for use by {@link ReactiveResource} that joins the given fields\n * with the optional separator (or '' if no separator is provided).\n *\n * Generally you should not need to import and use this function directly.\n *\n * @example\n * {\n *   name: 'fullName',\n *   kind: 'derived',\n *   type: 'concat',\n *   options: {\n *     fields: ['firstName', 'lastName'],\n *     separator: ' ',\n *   },\n * }\n */\nexport const concat: ConcatDerivation = (\n  record: ReactiveResource & { [key: string]: unknown },\n  options: Record<string, unknown> | null,\n  _prop: string\n) => {\n  if (!options) {\n    throw new Error(`options is required`);\n  }\n  // SAFETY: we cast internally to a more specific type, for our own use\n  // SAFETY: but provide the more general signature to the schema service\n  const opts = options as { fields: string[]; separator?: string };\n  return opts.fields.map((field) => record[field]).join(opts.separator ?? '');\n};\nconcat[Type] = 'concat';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AA6BA,MAAaC,UACXC,QACAC,SACAC,UACG;CACH,IAAI,CAACD,SACH,MAAM,IAAIE,MAAM,qBAAqB;CAIvC,MAAMC,OAAOH;CACb,OAAOG,KAAKC,OAAOC,KAAKC,UAAUP,OAAOO,MAAM,CAAC,CAACC,KAAKJ,KAAKK,aAAa,EAAE;AAC5E;AACAV,OAAOD,QAAQ"}

package/dist/unpkg/prod/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