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

package/dist/unpkg/dev-deprecated/request-CwjpJB3r.js

@@ -0,0 +1,756 @@
+import { n as getOrSetUniversal, t as getOrSetGlobal } from "./-private-D6Tw25AD.js";
+import { IS_FUTURE, STRUCTURED, SkipCache } from "./types/request.js";
+import { CACHE_OWNER } from "./types/identifier.js";
+
+//#region src/request/-private/debug.ts
+const BODY_TYPES = {
+	type: "string",
+	klass: [
+		"Blob",
+		"ArrayBuffer",
+		"TypedArray",
+		"DataView",
+		"FormData",
+		"URLSearchParams",
+		"ReadableStream"
+	]
+};
+const ValidKeys = /* @__PURE__ */ new Map([
+	["duplex", ["half"]],
+	["records", "array"],
+	["data", "json"],
+	["body", BODY_TYPES],
+	["disableTestWaiter", "boolean"],
+	["options", "object"],
+	["cacheOptions", "object"],
+	["priority", [
+		"high",
+		"low",
+		"auto"
+	]],
+	["op", "string"],
+	["store", "object"],
+	["url", "string"],
+	["cache", [
+		"default",
+		"force-cache",
+		"no-cache",
+		"no-store",
+		"only-if-cached",
+		"reload"
+	]],
+	["credentials", [
+		"include",
+		"omit",
+		"same-origin"
+	]],
+	["destination", [
+		"",
+		"object",
+		"audio",
+		"audioworklet",
+		"document",
+		"embed",
+		"font",
+		"frame",
+		"iframe",
+		"image",
+		"manifest",
+		"paintworklet",
+		"report",
+		"script",
+		"sharedworker",
+		"style",
+		"track",
+		"video",
+		"worker",
+		"xslt"
+	]],
+	["headers", "headers"],
+	["integrity", "string"],
+	["keepalive", "boolean"],
+	["method", [
+		"QUERY",
+		"GET",
+		"PUT",
+		"PATCH",
+		"DELETE",
+		"POST",
+		"OPTIONS",
+		"HEAD",
+		"CONNECT",
+		"TRACE"
+	]],
+	["mode", [
+		"same-origin",
+		"cors",
+		"navigate",
+		"no-cors"
+	]],
+	["redirect", [
+		"error",
+		"follow",
+		"manual"
+	]],
+	["referrer", "string"],
+	["signal", "AbortSignal"],
+	["controller", "AbortController"],
+	["referrerPolicy", [
+		"",
+		"same-origin",
+		"no-referrer",
+		"no-referrer-when-downgrade",
+		"origin",
+		"origin-when-cross-origin",
+		"strict-origin",
+		"strict-origin-when-cross-origin",
+		"unsafe-url"
+	]]
+]);
+const IS_FROZEN = getOrSetGlobal("IS_FROZEN", Symbol("FROZEN"));
+const IS_COLLECTION = getOrSetGlobal("IS_COLLECTION", Symbol.for("Collection"));
+function freezeHeaders(headers) {
+	headers.delete = headers.set = headers.append = () => {
+		throw new Error(`Cannot Mutate Immutatable Headers, use headers.clone to get a copy`);
+	};
+	upgradeHeaders(headers);
+	return headers;
+}
+function deepFreeze(value) {
+	if (value && value[IS_FROZEN]) return value;
+	switch (typeof value) {
+		case "boolean":
+		case "string":
+		case "number":
+		case "symbol":
+		case "undefined":
+		case "bigint": return value;
+		case "function": throw new Error(`Cannot deep-freeze a function`);
+		case "object": switch (niceTypeOf(value)) {
+			case "array": {
+				if (value[IS_COLLECTION]) return value;
+				const arr = value.map(deepFreeze);
+				arr[IS_FROZEN] = true;
+				return Object.freeze(arr);
+			}
+			case "null": return value;
+			case "object":
+				Object.keys(value).forEach((key) => {
+					try {
+						value[key] = deepFreeze(value[key]);
+					} catch {}
+				});
+				value[IS_FROZEN] = true;
+				return Object.freeze(value);
+			case "headers": return freezeHeaders(value);
+			case "Collection":
+			case "Store":
+			case "AbortSignal":
+			case "identifier": return value;
+			default: return value;
+		}
+	}
+}
+function isMaybeContext(request) {
+	if (request && typeof request === "object") {
+		const keys = Object.keys(request);
+		if (keys.length === 1 && keys[0] === "request") return true;
+	}
+	return false;
+}
+function niceTypeOf(v) {
+	if (v === null) return "null";
+	if (typeof v === "string") return v ? "non-empty-string" : "empty-string";
+	if (!v) return typeof v;
+	if (Array.isArray(v)) return "array";
+	if (v instanceof Date) return "date";
+	if (v instanceof Map) return "map";
+	if (v instanceof Set) return "set";
+	if (v instanceof Error) return "error";
+	if (v instanceof ReadableStream || v instanceof WritableStream || v instanceof TransformStream) return "stream";
+	if (v instanceof Headers) return "headers";
+	if (typeof v === "object" && CACHE_OWNER in v) return "identifier";
+	if (typeof v === "object" && v.constructor && v.constructor.name !== "Object") return v.constructor.name;
+	return typeof v;
+}
+function validateKey(key, value, errors) {
+	const schema = ValidKeys.get(key);
+	if (!schema && !IgnoredKeys.has(key)) {
+		errors.push(`InvalidKey: '${key}'`);
+		return;
+	}
+	if (schema) {
+		if (schema === BODY_TYPES) {
+			if (typeof value === "string" || value instanceof ReadableStream) return;
+			const type = niceTypeOf(value);
+			if (schema.klass.includes(type)) return;
+			errors.push(`InvalidValue: key 'body' should be a string or one of '${schema.klass.join("', '")}', received ${"<a value of type " + niceTypeOf(value) + ">"}`);
+			return;
+		}
+		if (Array.isArray(schema)) {
+			if (!schema.includes(value)) errors.push(`InvalidValue: key ${key} should be one of '${schema.join("', '")}', received ${typeof value === "string" ? value : "<a value of type " + niceTypeOf(value) + ">"}`);
+			return;
+		} else if (schema === "json") {
+			try {
+				JSON.stringify(value);
+			} catch (e) {
+				errors.push(`InvalidValue: key ${key} should be a JSON serializable value, but failed to serialize with Error - ${e.message}`);
+			}
+			return;
+		} else if (schema === "headers") {
+			if (!(value instanceof Headers)) errors.push(`InvalidValue: key ${key} should be an instance of Headers, received ${niceTypeOf(value)}`);
+			return;
+		} else if (schema === "record") {
+			if (!value || typeof value !== "object" || value.constructor && value.constructor !== Object) {
+				errors.push(`InvalidValue: key ${key} should be a dictionary of string keys to string values, received ${niceTypeOf(value)}`);
+				return;
+			}
+			Object.keys(value).forEach((k) => {
+				const v = value[k];
+				if (typeof k !== "string") errors.push(`\tThe key ${String(k)} on ${key} should be a string key`);
+				else if (typeof v !== "string") errors.push(`\tThe value of ${key}.${k} should be a string not ${niceTypeOf(v)}`);
+			});
+			return;
+		} else if (schema === "string") {
+			if (typeof value !== "string" || value.length === 0) errors.push(`InvalidValue: key ${key} should be a non-empty string, received ${typeof value === "string" ? "''" : typeof value}`);
+			return;
+		} else if (schema === "object") {
+			if (!value || Array.isArray(value) || typeof value !== "object") errors.push(`InvalidValue: key ${key} should be an object`);
+			return;
+		} else if (schema === "boolean") {
+			if (typeof value !== "boolean") errors.push(`InvalidValue: key ${key} should be a boolean, received ${typeof value}`);
+			return;
+		} else if (schema === "array") {
+			if (!Array.isArray(value)) errors.push(`InvalidValue: key ${key} should be an array, received ${typeof value}`);
+			return;
+		}
+	}
+}
+const IgnoredKeys = /* @__PURE__ */ new Set([]);
+function assertValidRequest(request, isTopLevel) {
+	{
+		if (!request) throw new Error(`Expected ${isTopLevel ? "RequestManager.request" : "next"}(<request>) to be called with a request, but none was provided.`);
+		if (Array.isArray(request) || typeof request !== "object") throw new Error(`The \`request\` passed to \`${isTopLevel ? "RequestManager.request" : "next"}(<request>)\` should be an object, received \`${niceTypeOf(request)}\``);
+		if (Object.keys(request).length === 0) throw new Error(`The \`request\` passed to \`${isTopLevel ? "RequestManager.request" : "next"}(<request>)\` was empty (\`{}\`). Requests need at least one valid key.`);
+		if (request instanceof Context) throw new Error(`Expected a request passed to \`${isTopLevel ? "RequestManager.request" : "next"}(<request>)\` but received the previous handler's context instead`);
+		if (isMaybeContext(request)) throw new Error(`Expected a request passed to \`${isTopLevel ? "RequestManager.request" : "next"}(<request>)\` but received an object with a request key instead.`);
+		const keys = Object.keys(request);
+		const validationErrors = [];
+		const isLegacyRequest = Boolean("op" in request && !request.url);
+		keys.forEach((key) => {
+			if (isLegacyRequest && key === "data") return;
+			validateKey(key, request[key], validationErrors);
+		});
+		if (validationErrors.length) {
+			const error = /* @__PURE__ */ new Error(`Invalid Request passed to \`${isTopLevel ? "RequestManager.request" : "next"}(<request>)\`.\n\nThe following issues were found:\n\n\t${validationErrors.join("\n	")}`);
+			error.errors = validationErrors;
+			throw error;
+		}
+	}
+}
+
+//#endregion
+//#region src/request/-private/context.ts
+function upgradeHeaders(headers) {
+	headers.clone = () => {
+		return new Headers(headers);
+	};
+	headers.toJSON = () => {
+		return Array.from(headers);
+	};
+	return headers;
+}
+function cloneResponseProperties(response) {
+	const { headers, ok, redirected, status, statusText, type, url } = response;
+	upgradeHeaders(headers);
+	return {
+		headers,
+		ok,
+		redirected,
+		status,
+		statusText,
+		type,
+		url
+	};
+}
+var ContextOwner = class {
+	hasSetStream = false;
+	hasSetResponse = false;
+	hasSubscribers = false;
+	stream = createDeferred();
+	response = null;
+	nextCalled = 0;
+	constructor(request, god, isRoot = false) {
+		this.isRoot = isRoot;
+		this.requestId = god.id;
+		this.controller = request.controller || god.controller;
+		this.stream.promise.sizeHint = 0;
+		if (request.controller) {
+			if (request.controller !== god.controller) god.controller.signal.addEventListener("abort", () => {
+				this.controller.abort(god.controller.signal.reason);
+			});
+			delete request.controller;
+		}
+		let enhancedRequest = Object.assign({ signal: this.controller.signal }, request);
+		if (!request?.cacheOptions?.[SkipCache]) {
+			request = deepFreeze(request);
+			enhancedRequest = deepFreeze(enhancedRequest);
+		}
+		this.enhancedRequest = enhancedRequest;
+		this.request = request;
+		this.god = god;
+		this.stream.promise = this.stream.promise.then((stream) => {
+			if (this.god.stream === stream && this.hasSubscribers) this.god.stream = null;
+			return stream;
+		});
+	}
+	get hasRequestedStream() {
+		return this.god.hasRequestedStream;
+	}
+	getResponse() {
+		if (this.hasSetResponse) return this.response;
+		if (this.nextCalled === 1) return this.god.response;
+		return null;
+	}
+	getStream() {
+		if (this.isRoot) this.god.hasRequestedStream = true;
+		if (!this.hasSetResponse) {
+			const hint = this.god.response?.headers?.get("content-length");
+			this.stream.promise.sizeHint = hint ? parseInt(hint, 10) : 0;
+		}
+		this.hasSubscribers = true;
+		return this.stream.promise;
+	}
+	abort(reason) {
+		this.controller.abort(reason);
+	}
+	setStream(stream) {
+		if (!this.hasSetStream) {
+			this.hasSetStream = true;
+			if (!(stream instanceof Promise)) this.god.stream = stream;
+			this.stream.resolve(stream);
+		}
+	}
+	resolveStream() {
+		this.setStream(this.nextCalled === 1 ? this.god.stream : null);
+	}
+	setResponse(response) {
+		if (this.hasSetResponse) throw new Error(`Cannot setResponse when a response has already been set`);
+		this.hasSetResponse = true;
+		if (response instanceof Response) {
+			let responseData = cloneResponseProperties(response);
+			responseData = deepFreeze(responseData);
+			this.response = responseData;
+			this.god.response = responseData;
+			const sizeHint = response.headers?.get("content-length");
+			this.stream.promise.sizeHint = sizeHint ? parseInt(sizeHint, 10) : 0;
+		} else {
+			this.response = response;
+			this.god.response = response;
+		}
+	}
+};
+/**
+* The context object given to each {@link Handler} (or {@link CacheHandler})
+* as it processes a request. It exposes the (immutable, enhanced) request
+* along with the methods a handler uses to build up the {@link Future} and
+* {@link StructuredDataDocument} that will ultimately be returned by the
+* {@link RequestManager}.
+*
+* @public
+*/
+var Context = class {
+	/** @internal */
+	/**
+	* A readonly, immutable version of the request being handled, including
+	* any defaults or enhancements applied by the {@link RequestManager}.
+	*
+	* @public
+	*/
+	/**
+	* The id of this request as assigned by the {@link RequestManager}. Not
+	* unique across manager instances.
+	*
+	* @public
+	*/
+	/** @internal */
+	/** @internal */
+	constructor(owner, isCacheHandler) {
+		this.id = owner.requestId;
+		this.___owner = owner;
+		this.request = owner.enhancedRequest;
+		this._isCacheHandler = isCacheHandler;
+		this._finalized = false;
+	}
+	/**
+	* Set the response stream for this request. May be called at most once,
+	* and may be called at any point up until the handler's `request` method
+	* resolves.
+	*
+	* @public
+	*/
+	setStream(stream) {
+		this.___owner.setStream(stream);
+	}
+	/**
+	* Set the {@link ResponseInfo} (or raw `Response`) associated with this
+	* request. Used to populate the response information available on the
+	* resulting {@link StructuredDataDocument}.
+	*
+	* @public
+	*/
+	setResponse(response) {
+		this.___owner.setResponse(response);
+	}
+	/**
+	* Associate a {@link RequestKey} with this request. May only be called
+	* synchronously from a {@link CacheHandler}.
+	*
+	* @public
+	*/
+	setIdentifier(identifier) {
+		((test) => {
+			if (!test) throw new Error(`setIdentifier may only be used synchronously from a CacheHandler`);
+		})(identifier && this._isCacheHandler && !this._finalized);
+		this.___owner.god.identifier = identifier;
+	}
+	/**
+	* Whether the application (or a downstream handler) has requested access
+	* to the response stream via {@link Future.getStream}. Handlers can use
+	* this to avoid the cost of streaming when nothing will consume it.
+	*
+	* @public
+	*/
+	get hasRequestedStream() {
+		return this.___owner.hasRequestedStream;
+	}
+	/** @private */
+	_finalize() {
+		this._finalized = true;
+	}
+};
+
+//#endregion
+//#region src/request/-private/promise-cache.ts
+/**
+* The minimal, structural subset of the `Promise` interface required to be
+* cached and inspected by {@link setPromiseResult} / {@link getPromiseResult}
+* (and by `getPromiseState`). Anything that is at least `then`/`catch`/`finally`
+* "shaped" (including a real `Promise` or {@link Future}) satisfies this.
+*
+* @public
+*/
+const PromiseCache = getOrSetUniversal("PromiseCache", /* @__PURE__ */ new WeakMap());
+const RequestMap = getOrSetUniversal("RequestMap", /* @__PURE__ */ new Map());
+function setRequestResult(requestId, result) {
+	RequestMap.set(requestId, result);
+}
+function clearRequestResult(requestId) {
+	RequestMap.delete(requestId);
+}
+function getRequestResult(requestId) {
+	return RequestMap.get(requestId);
+}
+/**
+* Cache the settled result (or error) of a promise-like value so that its
+* outcome can be synchronously read later via {@link getPromiseResult},
+* without needing to await it again.
+*
+* @public
+*/
+function setPromiseResult(promise, result) {
+	PromiseCache.set(promise, result);
+}
+/**
+* Synchronously read the settled result (or error) previously recorded for
+* a promise-like value via {@link setPromiseResult}, if any.
+*
+* @public
+*/
+function getPromiseResult(promise) {
+	return PromiseCache.get(promise);
+}
+
+//#endregion
+//#region src/request/-private/utils.ts
+const IS_CACHE_HANDLER = getOrSetGlobal("IS_CACHE_HANDLER", Symbol("IS_CACHE_HANDLER"));
+/**
+* A ponyfill for the global {@link DOMException} constructor.
+*
+* Some non-DOM environments (e.g. React Native, some Node/worker
+* environments) don't provide `DOMException` as a global, which would
+* otherwise throw a `ReferenceError` the first time any code referenced it
+* (for instance when classifying an abort/network error). `DOMError` falls
+* back to the global {@link Error} constructor in that case so callers can
+* uniformly use `new DOMError(...)` / `error instanceof DOMError` without
+* guarding for the global's presence themselves.
+*
+* @internal
+*/
+const DOMError = typeof DOMException !== "undefined" ? DOMException : Error;
+function curryFuture(owner, inbound, outbound) {
+	owner.setStream(inbound.getStream());
+	inbound.then((doc) => {
+		const document = {
+			[STRUCTURED]: true,
+			request: owner.request,
+			response: doc.response,
+			content: doc.content
+		};
+		outbound.resolve(document);
+	}, (error) => {
+		if (isDoc(error)) owner.setStream(owner.god.stream);
+		if (!error || !(error instanceof Error)) try {
+			throw new Error(error ? error : `Request Rejected with an Unknown Error`);
+		} catch (e) {
+			if (error && typeof error === "object") {
+				Object.assign(e, error);
+				e.message = error.message || `Request Rejected with an Unknown Error`;
+			}
+			error = e;
+		}
+		error[STRUCTURED] = true;
+		error.request = owner.request;
+		error.response = owner.getResponse();
+		error.error = error.error || error.message;
+		outbound.reject(error);
+	});
+	return outbound.promise;
+}
+function isDoc(doc) {
+	return doc && doc[STRUCTURED] === true;
+}
+function ensureDoc(owner, content, isError) {
+	if (isDoc(content)) return content;
+	if (isError) return {
+		[STRUCTURED]: true,
+		request: owner.request,
+		response: owner.getResponse(),
+		error: content
+	};
+	return {
+		[STRUCTURED]: true,
+		request: owner.request,
+		response: owner.getResponse(),
+		content
+	};
+}
+/**
+* Additional properties exposed on errors thrown by the
+* {@link Fetch | Fetch Handler}.
+*
+* In the case of an Abort or system/browser level issue,
+* this extends {@link DOMException}.
+*
+* Else it extends from {@link AggregateError} if the
+* response includes an array of errors, falling back
+* to {@link Error} as its base.
+*/
+function enhanceReason(reason) {
+	const error = new DOMError(reason || "The user aborted a request.", "AbortError");
+	if (error.name !== "AbortError") error.name = "AbortError";
+	return error;
+}
+function handleOutcome(owner, inbound, outbound) {
+	inbound.then((content) => {
+		if (owner.controller.signal.aborted) {
+			outbound.reject(enhanceReason(owner.controller.signal.reason));
+			return;
+		}
+		if (isDoc(content)) {
+			owner.setStream(owner.god.stream);
+			content = content.content;
+		}
+		const document = {
+			[STRUCTURED]: true,
+			request: owner.request,
+			response: owner.getResponse(),
+			content
+		};
+		outbound.resolve(document);
+	}, (error) => {
+		if (isDoc(error)) owner.setStream(owner.god.stream);
+		if (!error || !(error instanceof Error)) try {
+			throw new Error(error ? error : `Request Rejected with an Unknown Error`);
+		} catch (e) {
+			if (error && typeof error === "object") {
+				Object.assign(e, error);
+				e.message = error.message || `Request Rejected with an Unknown Error`;
+			}
+			error = e;
+		}
+		error[STRUCTURED] = true;
+		error.request = owner.request;
+		error.response = owner.getResponse();
+		error.error = error.error || error.message;
+		outbound.reject(error);
+	});
+	return outbound.promise;
+}
+function isCacheHandler(handler, index) {
+	return index === 0 && Boolean(handler[IS_CACHE_HANDLER]);
+}
+function executeNextHandler(wares, request, i, god) {
+	if (i === wares.length) throw new Error(`No handler was able to handle this request.`);
+	assertValidRequest(request, false);
+	const owner = new ContextOwner(request, god, i === 0);
+	function next(r) {
+		owner.nextCalled++;
+		return executeNextHandler(wares, r, i + 1, god);
+	}
+	const _isCacheHandler = isCacheHandler(wares[i], i);
+	const context = new Context(owner, _isCacheHandler);
+	let outcome;
+	try {
+		outcome = wares[i].request(context, next);
+		if (_isCacheHandler) context._finalize();
+		if (!!outcome && _isCacheHandler) {
+			if (!(outcome instanceof Promise)) {
+				setRequestResult(owner.requestId, {
+					isError: false,
+					result: ensureDoc(owner, outcome, false)
+				});
+				outcome = Promise.resolve(outcome);
+			}
+		} else if (!outcome || !(outcome instanceof Promise) && !(typeof outcome === "object" && "then" in outcome)) {
+			console.log({
+				request,
+				handler: wares[i],
+				outcome
+			});
+			if (outcome === void 0) throw new Error(`Expected handler.request to return a promise, instead received undefined.`);
+			throw new Error(`Expected handler.request to return a promise, instead received a synchronous value.`);
+		}
+	} catch (e) {
+		if (_isCacheHandler) setRequestResult(owner.requestId, {
+			isError: true,
+			result: ensureDoc(owner, e, true)
+		});
+		outcome = Promise.reject(e);
+	}
+	const future = createFuture(owner);
+	if (isFuture(outcome)) return curryFuture(owner, outcome, future);
+	return handleOutcome(owner, outcome, future);
+}
+
+//#endregion
+//#region src/request/-private/future.ts
+function isFuture(maybe) {
+	return Boolean(maybe && maybe instanceof Promise && maybe[IS_FUTURE] === true);
+}
+/**
+* Create a {@link Deferred}: a promise along with the `resolve`/`reject`
+* callbacks that settle it, so the promise can be handed out before the
+* work that will settle it has started.
+*
+* @public
+*/
+function createDeferred() {
+	let resolve;
+	let reject;
+	const promise = new Promise((res, rej) => {
+		resolve = res;
+		reject = rej;
+	});
+	return {
+		resolve,
+		reject,
+		promise
+	};
+}
+function upgradePromise(promise, future) {
+	promise[IS_FUTURE] = true;
+	promise.getStream = future.getStream;
+	promise.abort = future.abort;
+	promise.onFinalize = future.onFinalize;
+	promise.id = future.id;
+	promise.lid = future.lid;
+	promise.requester = future.requester;
+	promise.toJSON = () => {
+		const id = "Future<" + promise.id + ">";
+		if (promise.lid) return `${id} (${promise.lid.lid})`;
+		return id;
+	};
+	return promise;
+}
+function createFuture(owner) {
+	const deferred = createDeferred();
+	let { promise } = deferred;
+	let cbs;
+	promise = promise.finally(() => {
+		owner.resolveStream();
+		if (cbs) cbs.forEach((cb) => cb());
+	});
+	promise.onFinalize = (fn) => {
+		cbs = cbs || [];
+		cbs.push(fn);
+	};
+	promise[IS_FUTURE] = true;
+	promise.getStream = () => {
+		return owner.getStream();
+	};
+	promise.abort = (reason) => {
+		owner.abort(enhanceReason(reason));
+	};
+	promise.id = owner.requestId;
+	promise.lid = owner.god.identifier;
+	promise.requester = owner.god.requester;
+	promise.toJSON = () => {
+		const id = "Future<" + promise.id + ">";
+		if (promise.lid) return `${id} (${promise.lid.lid})`;
+		return id;
+	};
+	deferred.promise = promise;
+	return deferred;
+}
+
+//#endregion
+//#region src/request.ts
+/**
+* Brands the supplied object with the supplied response type.
+*
+* ```ts
+* import type { ReactiveDataDocument } from '@warp-drive/core/reactive';
+* import { withResponseType } from '@warp-drive/core/request';
+* import type { User } from '#/data/user.ts'
+*
+* const result = await store.request(
+*  withResponseType<ReactiveDataDocument<User>>({ url: '/users/1' })
+* );
+*
+* result.content.data; // will have type User
+* ```
+*
+*/
+function withResponseType(obj) {
+	return obj;
+}
+/**
+* Brands the supplied object with the supplied response type
+* wrapped in {@link ReactiveDataDocument}. This is a convenience for
+* the common case of using {@link withResponseType} with `ReactiveDataDocument`.
+*
+* ```ts
+* import { withReactiveResponse } from '@warp-drive/core/request';
+* import type { User } from '#/data/user.ts'
+*
+* const result = await store.request(
+*   withReactiveResponse<User>({ url: '/users/1' })
+* );
+*
+* result.content.data; // will have type User
+* ```
+*
+* @public
+*/
+function withReactiveResponse(obj) {
+	return obj;
+}
+/**
+* @deprecated use {@link withResponseType} instead
+*/
+const withBrand = withResponseType;
+
+//#endregion
+export { upgradePromise as a, executeNextHandler as c, getRequestResult as d, setPromiseResult as f, createDeferred as i, clearRequestResult as l, assertValidRequest as m, withReactiveResponse as n, DOMError as o, cloneResponseProperties as p, withResponseType as r, IS_CACHE_HANDLER as s, withBrand as t, getPromiseResult as u };
+//# sourceMappingURL=request-CwjpJB3r.js.map