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

package/dist/unpkg/prod-deprecated/request-BcJNzSgv.js

@@ -0,0 +1,480 @@
+import { n as getOrSetUniversal, t as getOrSetGlobal } from "./-private-BK71-uXR.js";
+import { IS_FUTURE, STRUCTURED } from "./types/request.js";
+
+//#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.headers) upgradeHeaders(request.headers);
+		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) return;
+		this.hasSetResponse = true;
+		if (response instanceof Response) {
+			let responseData = cloneResponseProperties(response);
+			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) {
+		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) {
+	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);
+			}
+		}
+	} 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;
+	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;
+	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, 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-BcJNzSgv.js.map

package/dist/unpkg/prod-deprecated/request-BcJNzSgv.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-BcJNzSgv.js","names":["SkipCache","deepFreeze","createDeferred","upgradeHeaders","headers","clone","Headers","toJSON","Array","from","cloneResponseProperties","response","ok","redirected","status","statusText","type","url","ContextOwner","hasSetStream","hasSetResponse","hasSubscribers","stream","nextCalled","constructor","request","god","isRoot","requestId","id","controller","promise","sizeHint","signal","addEventListener","abort","reason","enhancedRequest","Object","assign","then","hasRequestedStream","getResponse","getStream","hint","get","parseInt","setStream","Promise","resolve","resolveStream","setResponse","Response","responseData","Context","owner","isCacheHandler","___owner","_isCacheHandler","_finalized","setIdentifier","identifier","_finalize","getOrSetUniversal","PromiseCache","WeakMap","RequestMap","Map","setRequestResult","requestId","result","set","clearRequestResult","delete","getRequestResult","get","setPromiseResult","promise","getPromiseResult","getOrSetGlobal","STRUCTURED","Context","ContextOwner","assertValidRequest","createFuture","isFuture","setRequestResult","IS_CACHE_HANDLER","Symbol","DOMError","DOMException","Error","curryFuture","owner","inbound","outbound","setStream","getStream","then","doc","document","request","response","content","resolve","error","isDoc","god","stream","e","Object","assign","message","getResponse","reject","promise","ensureDoc","isError","enhanceReason","reason","name","handleOutcome","controller","signal","aborted","isCacheHandler","handler","index","Boolean","executeNextHandler","wares","i","next","r","nextCalled","_isCacheHandler","context","outcome","_finalize","Promise","requestId","result","future","IS_FUTURE","enhanceReason","isFuture","maybe","Boolean","Promise","createDeferred","resolve","reject","promise","res","rej","upgradePromise","future","getStream","abort","onFinalize","id","lid","requester","createFuture","owner","deferred","cbs","finally","resolveStream","forEach","cb","fn","push","reason","requestId","god","identifier","createDeferred","setPromiseResult","getPromiseResult","withResponseType","obj","withReactiveResponse","withBrand"],"sources":["../../../src/request/-private/context.ts","../../../src/request/-private/promise-cache.ts","../../../src/request/-private/utils.ts","../../../src/request/-private/future.ts","../../../src/request.ts"],"sourcesContent":["import { DEBUG } from '@warp-drive/core/build-config/env';\nimport { assert } from '@warp-drive/core/build-config/macros';\n\nimport type { RequestKey } from '../../types/identifier';\nimport type { ImmutableHeaders, ImmutableRequestInfo, RequestInfo, ResponseInfo } from '../../types/request';\nimport { SkipCache } from '../../types/request';\nimport { deepFreeze } from './debug';\nimport { createDeferred } from './future';\nimport type { DeferredStream, GodContext } from './types';\n\nexport function upgradeHeaders(headers: Headers | ImmutableHeaders): ImmutableHeaders {\n  (headers as ImmutableHeaders).clone = () => {\n    return new Headers(headers);\n  };\n  (headers as ImmutableHeaders).toJSON = () => {\n    return Array.from(headers as unknown as Iterable<[string, string]>);\n  };\n  return headers as ImmutableHeaders;\n}\n\nexport function cloneResponseProperties(response: Response): ResponseInfo {\n  const { headers, ok, redirected, status, statusText, type, url } = response;\n  upgradeHeaders(headers);\n  return {\n    headers: headers as ImmutableHeaders,\n    ok,\n    redirected,\n    status,\n    statusText,\n    type,\n    url,\n  };\n}\n\nexport class ContextOwner {\n  hasSetStream = false;\n  hasSetResponse = false;\n  hasSubscribers = false;\n  stream: DeferredStream = createDeferred<ReadableStream | null>();\n  response: ResponseInfo | null = null;\n  declare request: ImmutableRequestInfo;\n  declare enhancedRequest: ImmutableRequestInfo;\n  nextCalled = 0;\n  declare god: GodContext;\n  declare controller: AbortController;\n  declare requestId: number;\n  declare isRoot: boolean;\n\n  constructor(request: RequestInfo, god: GodContext, isRoot = false) {\n    this.isRoot = isRoot;\n    this.requestId = god.id;\n    this.controller = request.controller || god.controller;\n    this.stream.promise.sizeHint = 0;\n\n    if (request.controller) {\n      if (request.controller !== god.controller) {\n        god.controller.signal.addEventListener('abort', () => {\n          this.controller.abort(god.controller.signal.reason);\n        });\n      }\n      delete request.controller;\n    }\n    let enhancedRequest: ImmutableRequestInfo = Object.assign(\n      { signal: this.controller.signal },\n      request\n    ) as ImmutableRequestInfo;\n    if (DEBUG) {\n      if (!request?.cacheOptions?.[SkipCache]) {\n        request = deepFreeze(request) as ImmutableRequestInfo;\n        enhancedRequest = deepFreeze(enhancedRequest);\n      }\n    } else {\n      if (request.headers) {\n        upgradeHeaders(request.headers);\n      }\n    }\n    this.enhancedRequest = enhancedRequest;\n    this.request = request as ImmutableRequestInfo;\n    this.god = god;\n    this.stream.promise = this.stream.promise.then((stream: ReadableStream | null) => {\n      if (this.god.stream === stream && this.hasSubscribers) {\n        this.god.stream = null;\n      }\n      return stream;\n    });\n  }\n\n  get hasRequestedStream(): boolean {\n    return this.god.hasRequestedStream;\n  }\n\n  getResponse(): ResponseInfo | null {\n    if (this.hasSetResponse) {\n      return this.response;\n    }\n    if (this.nextCalled === 1) {\n      return this.god.response;\n    }\n    return null;\n  }\n  getStream(): Promise<ReadableStream | null> {\n    if (this.isRoot) {\n      this.god.hasRequestedStream = true;\n    }\n    if (!this.hasSetResponse) {\n      const hint = this.god.response?.headers?.get('content-length');\n      this.stream.promise.sizeHint = hint ? parseInt(hint, 10) : 0;\n    }\n    this.hasSubscribers = true;\n    return this.stream.promise;\n  }\n  abort(reason: DOMException): void {\n    this.controller.abort(reason);\n  }\n\n  setStream(stream: ReadableStream | Promise<ReadableStream | null> | null): void {\n    if (!this.hasSetStream) {\n      this.hasSetStream = true;\n\n      if (!(stream instanceof Promise)) {\n        this.god.stream = stream;\n      }\n      // @ts-expect-error\n      this.stream.resolve(stream);\n    }\n  }\n\n  resolveStream(): void {\n    this.setStream(this.nextCalled === 1 ? this.god.stream : null);\n  }\n\n  setResponse(response: ResponseInfo | Response | null): void {\n    if (this.hasSetResponse) {\n      if (DEBUG) {\n        throw new Error(`Cannot setResponse when a response has already been set`);\n      }\n      return;\n    }\n    this.hasSetResponse = true;\n    if (response instanceof Response) {\n      // TODO potentially avoid cloning in prod\n      let responseData = cloneResponseProperties(response);\n\n      if (DEBUG) {\n        responseData = deepFreeze(responseData);\n      }\n      this.response = responseData;\n      this.god.response = responseData;\n      const sizeHint = response.headers?.get('content-length');\n      this.stream.promise.sizeHint = sizeHint ? parseInt(sizeHint, 10) : 0;\n    } else {\n      this.response = response;\n      this.god.response = response;\n    }\n  }\n}\n\n/**\n * The context object given to each {@link Handler} (or {@link CacheHandler})\n * as it processes a request. It exposes the (immutable, enhanced) request\n * along with the methods a handler uses to build up the {@link Future} and\n * {@link StructuredDataDocument} that will ultimately be returned by the\n * {@link RequestManager}.\n *\n * @public\n */\nexport class Context {\n  /** @internal */\n  declare private ___owner: ContextOwner;\n  /**\n   * A readonly, immutable version of the request being handled, including\n   * any defaults or enhancements applied by the {@link RequestManager}.\n   *\n   * @public\n   */\n  declare request: ImmutableRequestInfo;\n  /**\n   * The id of this request as assigned by the {@link RequestManager}. Not\n   * unique across manager instances.\n   *\n   * @public\n   */\n  declare id: number;\n  /** @internal */\n  declare private _isCacheHandler: boolean;\n  /** @internal */\n  declare private _finalized: boolean;\n\n  constructor(owner: ContextOwner, isCacheHandler: boolean) {\n    this.id = owner.requestId;\n    this.___owner = owner;\n    this.request = owner.enhancedRequest;\n    this._isCacheHandler = isCacheHandler;\n    this._finalized = false;\n  }\n  /**\n   * Set the response stream for this request. May be called at most once,\n   * and may be called at any point up until the handler's `request` method\n   * resolves.\n   *\n   * @public\n   */\n  setStream(stream: ReadableStream | Promise<ReadableStream | null>): void {\n    this.___owner.setStream(stream);\n  }\n  /**\n   * Set the {@link ResponseInfo} (or raw `Response`) associated with this\n   * request. Used to populate the response information available on the\n   * resulting {@link StructuredDataDocument}.\n   *\n   * @public\n   */\n  setResponse(response: ResponseInfo | Response | null): void {\n    this.___owner.setResponse(response);\n  }\n\n  /**\n   * Associate a {@link RequestKey} with this request. May only be called\n   * synchronously from a {@link CacheHandler}.\n   *\n   * @public\n   */\n  setIdentifier(identifier: RequestKey): void {\n    assert(\n      `setIdentifier may only be used synchronously from a CacheHandler`,\n      identifier && this._isCacheHandler && !this._finalized\n    );\n    this.___owner.god.identifier = identifier;\n  }\n\n  /**\n   * Whether the application (or a downstream handler) has requested access\n   * to the response stream via {@link Future.getStream}. Handlers can use\n   * this to avoid the cost of streaming when nothing will consume it.\n   *\n   * @public\n   */\n  get hasRequestedStream(): boolean {\n    return this.___owner.hasRequestedStream;\n  }\n\n  /** @private */\n  _finalize(): void {\n    this._finalized = true;\n  }\n}\nexport type HandlerRequestContext = Context;\n","import { getOrSetUniversal } from '../../types/-private';\n\nexport type CacheResult<T = unknown, E = unknown> = { isError: true; result: E } | { isError: false; result: T };\n\n/**\n * The minimal, structural subset of the `Promise` interface required to be\n * cached and inspected by {@link setPromiseResult} / {@link getPromiseResult}\n * (and by `getPromiseState`). Anything that is at least `then`/`catch`/`finally`\n * \"shaped\" (including a real `Promise` or {@link Future}) satisfies this.\n *\n * @public\n */\nexport type Awaitable<T = unknown, E = unknown> = {\n  /**\n   * Registers fulfillment/rejection handlers, `Promise.prototype.then`-style.\n   *\n   * @public\n   */\n  then: (onFulfilled: (value: T) => unknown, onRejected: (reason: E) => unknown) => unknown;\n  /**\n   * Registers a rejection handler, `Promise.prototype.catch`-style.\n   *\n   * @public\n   */\n  catch: (onRejected: (reason: E) => unknown) => unknown;\n  /**\n   * Registers a handler run on settlement, `Promise.prototype.finally`-style.\n   *\n   * @public\n   */\n  finally: (onFinally: () => unknown) => unknown;\n};\n\nexport const PromiseCache: WeakMap<Awaitable, CacheResult> = getOrSetUniversal(\n  'PromiseCache',\n  new WeakMap<Awaitable, CacheResult>()\n);\nexport const RequestMap: Map<number, CacheResult> = getOrSetUniversal('RequestMap', new Map<number, CacheResult>());\n\nexport function setRequestResult(requestId: number, result: CacheResult): void {\n  RequestMap.set(requestId, result);\n}\nexport function clearRequestResult(requestId: number): void {\n  RequestMap.delete(requestId);\n}\nexport function getRequestResult(requestId: number): CacheResult | undefined {\n  return RequestMap.get(requestId);\n}\n\n/**\n * Cache the settled result (or error) of a promise-like value so that its\n * outcome can be synchronously read later via {@link getPromiseResult},\n * without needing to await it again.\n *\n * @public\n */\nexport function setPromiseResult(promise: Promise<unknown> | Awaitable, result: CacheResult): void {\n  PromiseCache.set(promise, result);\n}\n\n/**\n * Synchronously read the settled result (or error) previously recorded for\n * a promise-like value via {@link setPromiseResult}, if any.\n *\n * @public\n */\nexport function getPromiseResult<T, E>(promise: Promise<T> | Awaitable<T, E>): CacheResult<T, E> | undefined {\n  return PromiseCache.get(promise) as CacheResult<T, E> | undefined;\n}\n","import { DEBUG } from '@warp-drive/core/build-config/env';\n\nimport { getOrSetGlobal } from '../../types/-private';\nimport type {\n  RequestInfo,\n  StructuredDataDocument,\n  StructuredDocument,\n  StructuredErrorDocument,\n} from '../../types/request';\nimport { STRUCTURED } from '../../types/request';\nimport { Context, ContextOwner } from './context';\nimport { assertValidRequest } from './debug';\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nimport type { Fetch } from './fetch.ts';\nimport { createFuture, isFuture } from './future';\nimport { setRequestResult } from './promise-cache';\nimport type { DeferredFuture, Future, GodContext, Handler } from './types';\n\nexport const IS_CACHE_HANDLER: '___(unique) Symbol(IS_CACHE_HANDLER)' = getOrSetGlobal(\n  'IS_CACHE_HANDLER',\n  Symbol('IS_CACHE_HANDLER')\n);\n\n/**\n * A ponyfill for the global {@link DOMException} constructor.\n *\n * Some non-DOM environments (e.g. React Native, some Node/worker\n * environments) don't provide `DOMException` as a global, which would\n * otherwise throw a `ReferenceError` the first time any code referenced it\n * (for instance when classifying an abort/network error). `DOMError` falls\n * back to the global {@link Error} constructor in that case so callers can\n * uniformly use `new DOMError(...)` / `error instanceof DOMError` without\n * guarding for the global's presence themselves.\n *\n * @internal\n */\nexport const DOMError: typeof DOMException =\n  typeof DOMException !== 'undefined' ? DOMException : (Error as unknown as typeof DOMException);\nexport function curryFuture<T>(owner: ContextOwner, inbound: Future<T>, outbound: DeferredFuture<T>): Future<T> {\n  owner.setStream(inbound.getStream());\n\n  inbound.then(\n    (doc: StructuredDataDocument<T>) => {\n      const document = {\n        [STRUCTURED]: true as const,\n        request: owner.request,\n        response: doc.response,\n        content: doc.content,\n      };\n      outbound.resolve(document);\n    },\n    (error: Error & StructuredErrorDocument) => {\n      if (isDoc(error)) {\n        owner.setStream(owner.god.stream);\n      }\n      if (!error || !(error instanceof Error)) {\n        try {\n          throw new Error(error ? error : `Request Rejected with an Unknown Error`);\n        } catch (e: unknown) {\n          if (error && typeof error === 'object') {\n            Object.assign(e as Error, error);\n            (e as Error & StructuredErrorDocument).message =\n              (error as Error).message || `Request Rejected with an Unknown Error`;\n          }\n          error = e as Error & StructuredErrorDocument;\n        }\n      }\n\n      error[STRUCTURED] = true;\n      error.request = owner.request;\n      error.response = owner.getResponse();\n      error.error = error.error || error.message;\n\n      outbound.reject(error);\n    }\n  );\n  return outbound.promise;\n}\n\nfunction isDoc<T>(doc: T | StructuredDataDocument<T>): doc is StructuredDataDocument<T> {\n  return doc && (doc as StructuredDataDocument<T>)[STRUCTURED] === true;\n}\n\nfunction ensureDoc<T>(owner: ContextOwner, content: T | Error, isError: boolean): StructuredDocument<T> {\n  if (isDoc(content)) {\n    return content as StructuredDocument<T>;\n  }\n\n  if (isError) {\n    return {\n      [STRUCTURED]: true,\n      request: owner.request,\n      response: owner.getResponse(),\n      error: content as Error,\n    } as StructuredErrorDocument<T>;\n  }\n\n  return {\n    [STRUCTURED]: true,\n    request: owner.request,\n    response: owner.getResponse(),\n    content: content as T,\n  };\n}\n\n/**\n * Additional properties exposed on errors thrown by the\n * {@link Fetch | Fetch Handler}.\n *\n * In the case of an Abort or system/browser level issue,\n * this extends {@link DOMException}.\n *\n * Else it extends from {@link AggregateError} if the\n * response includes an array of errors, falling back\n * to {@link Error} as its base.\n */\nexport interface FetchError extends DOMException {\n  /**\n   * Alias for {@link FetchError.status | status}.\n   *\n   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Response/status)\n   */\n  code: number;\n  /**\n   * The name associated to the {@link FetchError.status | status code}.\n   *\n   * Typically this will be of the formula `StatusTextError` for instance\n   * a 404 status with status text of `Not Found` would have the name\n   * `NotFoundError`.\n   */\n  name: string;\n  /**\n   * The http status code associated to the returned error.\n   *\n   * Browser/System level network errors will often have an error code of `0` or `5`.\n   * Aborted requests will have an error code of `20`.\n   *\n   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Response/status)\n   */\n  status: number;\n  /**\n   * The Status Text associated to the {@link FetchError.status | status code}\n   * for the error.\n   *\n   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Response/statusText)\n   *\n   */\n  statusText: string;\n  /**\n   * A property signifying that an Error uses the {@link FetchError}\n   * interface.\n   */\n  isRequestError: true;\n}\n\nexport function enhanceReason(reason?: string): DOMException {\n  const error = new DOMError(reason || 'The user aborted a request.', 'AbortError');\n  // `DOMError` may be the `Error` constructor as a fallback, whose\n  // constructor doesn't accept a `name`, so set it explicitly in that case.\n  // We can't unconditionally assign `error.name` here: when `DOMError` is\n  // the real `DOMException`, `name` is already `'AbortError'` (set by its\n  // constructor) *and* `DOMException.prototype.name` is a getter-only\n  // accessor with no setter, so reassigning it throws a `TypeError` in\n  // strict-mode JS (which is how our ES modules run) - even when assigning\n  // the very same value it already holds.\n  if (error.name !== 'AbortError') {\n    (error as unknown as { name: string }).name = 'AbortError';\n  }\n  return error;\n}\n\nexport function handleOutcome<T>(\n  owner: ContextOwner,\n  inbound: Promise<T | StructuredDataDocument<T>>,\n  outbound: DeferredFuture<T>\n): Future<T> {\n  inbound.then(\n    (content: T | StructuredDataDocument<T>) => {\n      if (owner.controller.signal.aborted) {\n        // the next function did not respect the signal, we handle it here\n        outbound.reject(enhanceReason(owner.controller.signal.reason as string));\n        return;\n      }\n      if (isDoc(content)) {\n        owner.setStream(owner.god.stream);\n        content = content.content;\n      }\n      const document = {\n        [STRUCTURED]: true as const,\n        request: owner.request,\n        response: owner.getResponse(),\n        content,\n      };\n      outbound.resolve(document);\n    },\n    (error: Error & StructuredErrorDocument) => {\n      if (isDoc(error)) {\n        owner.setStream(owner.god.stream);\n      }\n      if (!error || !(error instanceof Error)) {\n        try {\n          throw new Error(error ? error : `Request Rejected with an Unknown Error`);\n        } catch (e: unknown) {\n          if (error && typeof error === 'object') {\n            Object.assign(e as Error, error);\n            (e as Error & StructuredErrorDocument).message =\n              (error as Error).message || `Request Rejected with an Unknown Error`;\n          }\n          error = e as Error & StructuredErrorDocument;\n        }\n      }\n\n      error[STRUCTURED] = true;\n      error.request = owner.request;\n      error.response = owner.getResponse();\n      error.error = error.error || error.message;\n      outbound.reject(error);\n    }\n  );\n  return outbound.promise;\n}\n\nfunction isCacheHandler(handler: Handler & { [IS_CACHE_HANDLER]?: boolean }, index: number): boolean {\n  return index === 0 && Boolean(handler[IS_CACHE_HANDLER]);\n}\n\nexport function executeNextHandler<T>(\n  wares: Readonly<Handler[]>,\n  request: RequestInfo,\n  i: number,\n  god: GodContext\n): Future<T> {\n  if (DEBUG) {\n    if (i === wares.length) {\n      throw new Error(`No handler was able to handle this request.`);\n    }\n    assertValidRequest(request, false);\n  }\n  const owner = new ContextOwner(request, god, i === 0);\n\n  function next(r: RequestInfo): Future<T> {\n    owner.nextCalled++;\n    return executeNextHandler(wares, r, i + 1, god);\n  }\n\n  const _isCacheHandler = isCacheHandler(wares[i], i);\n  const context = new Context(owner, _isCacheHandler);\n  let outcome: Promise<T | StructuredDataDocument<T>> | Future<T>;\n  try {\n    outcome = wares[i].request<T>(context, next);\n    if (_isCacheHandler) {\n      context._finalize();\n    }\n    if (!!outcome && _isCacheHandler) {\n      if (!(outcome instanceof Promise)) {\n        setRequestResult(owner.requestId, { isError: false, result: ensureDoc(owner, outcome, false) });\n        outcome = Promise.resolve(outcome);\n      }\n    } else if (DEBUG) {\n      if (!outcome || (!(outcome instanceof Promise) && !(typeof outcome === 'object' && 'then' in outcome))) {\n        // eslint-disable-next-line no-console\n        console.log({ request, handler: wares[i], outcome });\n        if (outcome === undefined) {\n          throw new Error(`Expected handler.request to return a promise, instead received undefined.`);\n        }\n        throw new Error(`Expected handler.request to return a promise, instead received a synchronous value.`);\n      }\n    }\n  } catch (e) {\n    if (_isCacheHandler) {\n      setRequestResult(owner.requestId, { isError: true, result: ensureDoc(owner, e, true) });\n    }\n    // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors\n    outcome = Promise.reject<StructuredDataDocument<T>>(e);\n  }\n  const future = createFuture<T>(owner);\n\n  if (isFuture<T>(outcome)) {\n    return curryFuture(owner, outcome, future);\n  }\n\n  return handleOutcome(owner, outcome, future);\n}\n","import { DEBUG } from '@warp-drive/build-config/env';\n\nimport { IS_FUTURE, type StructuredDocument } from '../../types/request';\nimport type { ContextOwner } from './context';\nimport type { Deferred, DeferredFuture, Future } from './types';\nimport { enhanceReason } from './utils';\n\nexport function isFuture<T>(maybe: unknown): maybe is Future<T> {\n  return Boolean(maybe && maybe instanceof Promise && (maybe as Future<T>)[IS_FUTURE] === true);\n}\n\n/**\n * Create a {@link Deferred}: a promise along with the `resolve`/`reject`\n * callbacks that settle it, so the promise can be handed out before the\n * work that will settle it has started.\n *\n * @public\n */\nexport function createDeferred<T>(): Deferred<T> {\n  let resolve!: (v: T) => void;\n  let reject!: (v: unknown) => void;\n  const promise = new Promise<T>((res, rej) => {\n    resolve = res;\n    reject = rej;\n  });\n  return { resolve, reject, promise };\n}\n\nexport function upgradePromise<T>(promise: Promise<StructuredDocument<T>>, future: Future<T>): Future<T> {\n  (promise as Future<T>)[IS_FUTURE] = true;\n  // eslint-disable-next-line @typescript-eslint/unbound-method\n  (promise as Future<T>).getStream = future.getStream;\n  // eslint-disable-next-line @typescript-eslint/unbound-method\n  (promise as Future<T>).abort = future.abort;\n  // eslint-disable-next-line @typescript-eslint/unbound-method\n  (promise as Future<T>).onFinalize = future.onFinalize;\n  (promise as Future<T>).id = future.id;\n  (promise as Future<T>).lid = future.lid;\n  (promise as Future<T>).requester = future.requester;\n\n  if (DEBUG) {\n    // @ts-expect-error\n    promise.toJSON = () => {\n      const id = 'Future<' + (promise as Future<T>).id + '>';\n      if ((promise as Future<T>).lid) {\n        return `${id} (${(promise as Future<T>).lid!.lid})`;\n      }\n      return id;\n    };\n  }\n\n  return promise as Future<T>;\n}\n\nexport function createFuture<T>(owner: ContextOwner): DeferredFuture<T> {\n  const deferred = createDeferred<T>() as unknown as DeferredFuture<T>;\n  let { promise } = deferred;\n  let cbs: Array<() => void> | undefined;\n  promise = promise.finally(() => {\n    owner.resolveStream();\n    if (cbs) {\n      cbs.forEach((cb) => cb());\n    }\n  }) as Future<T>;\n  promise.onFinalize = (fn: () => void) => {\n    cbs = cbs || [];\n    cbs.push(fn);\n  };\n  promise[IS_FUTURE] = true;\n  promise.getStream = () => {\n    return owner.getStream();\n  };\n  promise.abort = (reason?: string) => {\n    owner.abort(enhanceReason(reason));\n  };\n  promise.id = owner.requestId;\n  promise.lid = owner.god.identifier;\n  promise.requester = owner.god.requester;\n\n  if (DEBUG) {\n    // @ts-expect-error\n    promise.toJSON = () => {\n      const id = 'Future<' + promise.id + '>';\n      if (promise.lid) {\n        return `${id} (${promise.lid.lid})`;\n      }\n      return id;\n    };\n  }\n\n  deferred.promise = promise;\n  return deferred;\n}\n","import type { ReactiveDataDocument } from './reactive.ts';\nimport type { RequestInfo } from './types/request.ts';\nimport type { RequestSignature } from './types/symbols.ts';\n\nexport { createDeferred } from './request/-private/future.ts';\nexport type {\n  Future,\n  Handler,\n  CacheHandler,\n  NextFn,\n  Deferred,\n  ManagedRequestPriority,\n} from './request/-private/types.ts';\nexport { setPromiseResult, getPromiseResult } from './request/-private/promise-cache.ts';\nexport type { Awaitable } from './request/-private/promise-cache.ts';\nexport type { Context } from './request/-private/context.ts';\n\n/**\n * Brands the supplied object with the supplied response type.\n *\n * ```ts\n * import type { ReactiveDataDocument } from '@warp-drive/core/reactive';\n * import { withResponseType } from '@warp-drive/core/request';\n * import type { User } from '#/data/user.ts'\n *\n * const result = await store.request(\n *  withResponseType<ReactiveDataDocument<User>>({ url: '/users/1' })\n * );\n *\n * result.content.data; // will have type User\n * ```\n *\n */\nexport function withResponseType<T>(obj: RequestInfo): RequestInfo<T> & {\n  /** The branded response type. Present only at the type level; carries no runtime value. */\n  [RequestSignature]: T;\n} {\n  return obj as RequestInfo<T> & {\n    [RequestSignature]: T;\n  };\n}\n\n/**\n * Brands the supplied object with the supplied response type\n * wrapped in {@link ReactiveDataDocument}. This is a convenience for\n * the common case of using {@link withResponseType} with `ReactiveDataDocument`.\n *\n * ```ts\n * import { withReactiveResponse } from '@warp-drive/core/request';\n * import type { User } from '#/data/user.ts'\n *\n * const result = await store.request(\n *   withReactiveResponse<User>({ url: '/users/1' })\n * );\n *\n * result.content.data; // will have type User\n * ```\n *\n * @public\n */\nexport function withReactiveResponse<T>(obj: RequestInfo): RequestInfo<ReactiveDataDocument<T>> & {\n  /** The branded response type. Present only at the type level; carries no runtime value. */\n  [RequestSignature]: ReactiveDataDocument<T>;\n} {\n  return obj as RequestInfo<ReactiveDataDocument<T>> & {\n    [RequestSignature]: ReactiveDataDocument<T>;\n  };\n}\n\n/**\n * @deprecated use {@link withResponseType} instead\n */\nexport const withBrand: typeof withResponseType = withResponseType;\n"],"mappings":"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"}

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

@@ -1,2 +1,3 @@
-export { d as createDeferred, w as withBrand, b as withReactiveResponse, a as withResponseType } from "./request-BrJSCG6r.js";
-export { b as getPromiseResult, s as setPromiseResult } from "./promise-cache-DIT8Ypjq.js";
+import { f as setPromiseResult, i as createDeferred, n as withReactiveResponse, r as withResponseType, t as withBrand, u as getPromiseResult } from "./request-BcJNzSgv.js";
+
+export { createDeferred, getPromiseResult, setPromiseResult, withBrand, withReactiveResponse, withResponseType };

package/dist/unpkg/prod-deprecated/signals/-leaked.js

@@ -1 +1,3 @@
-export { D as DISPOSE, d as defineGate, o as defineNonEnumerableSignal, j as defineSignal, k as entangleSignal, t as gate, u as memoized, n as notifyInternalSignal, p as peekInternalSignal, q as signal, r as waitFor, w as withSignalStore } from "../-leaked-DRNv9VIX.js";
+import { E as waitFor, S as withSignalStore, b as notifyInternalSignal, c as defineSignal, d as gate, f as memoized, n as DISPOSE, o as defineGate, p as signal, s as defineNonEnumerableSignal, u as entangleSignal, v as getOrCreateInternalSignal, x as peekInternalSignal, y as makeInitializer } from "../-private-TNaS5Piv.js";
+
+export { DISPOSE, defineGate, defineNonEnumerableSignal, defineSignal, entangleSignal, gate, getOrCreateInternalSignal, makeInitializer, memoized, notifyInternalSignal, peekInternalSignal, signal, waitFor, withSignalStore };