@warp-drive/core 5.6.0-alpha.15 → 5.6.0-alpha.17

package/declarations/request/-private/fetch.d.ts

@@ -1,32 +1,31 @@
-import { type Context } from './context';
+import { type Context } from "./context.js";
 interface FastbootRequest extends Request {
-    protocol: string;
-    host: string;
+	protocol: string;
+	host: string;
 }
 export interface FastBoot {
-    require(moduleName: string): unknown;
-    isFastBoot: boolean;
-    request: FastbootRequest;
+	require(moduleName: string): unknown;
+	isFastBoot: boolean;
+	request: FastbootRequest;
 }
 /**
- * ```ts
- * import { Fetch } from '@warp-drive/core';
- * ```
- *
- * A basic Fetch Handler which converts a request into a
- * `fetch` call presuming the response to be `json`.
- *
- * ```ts
- * import { RequestManager, Fetch } from '@warp-drive/core';
- *
- * const manager = new RequestManager()
- *   .use([Fetch]);
- * ```
- *
- * @public
- */
+* ```ts
+* import { Fetch } from '@warp-drive/core';
+* ```
+*
+* A basic Fetch Handler which converts a request into a
+* `fetch` call presuming the response to be `json`.
+*
+* ```ts
+* import { RequestManager, Fetch } from '@warp-drive/core';
+*
+* const manager = new RequestManager()
+*   .use([Fetch]);
+* ```
+*
+* @public
+*/
 declare const Fetch: {
-    request<T>(context: Context): Promise<T>;
+	request<T>(context: Context): Promise<T>;
 };
 export { Fetch };
-//# sourceMappingURL=fetch.d.ts.map

package/declarations/request/-private/future.d.ts

@@ -1,8 +1,7 @@
-import { type StructuredDocument } from '../../types/request';
-import type { ContextOwner } from './context';
-import type { Deferred, DeferredFuture, Future } from './types';
+import { type StructuredDocument } from "../../types/request.js";
+import type { ContextOwner } from "./context.js";
+import type { Deferred, DeferredFuture, Future } from "./types.js";
 export declare function isFuture<T>(maybe: unknown): maybe is Future<T>;
 export declare function createDeferred<T>(): Deferred<T>;
 export declare function upgradePromise<T>(promise: Promise<StructuredDocument<T>>, future: Future<T>): Future<T>;
 export declare function createFuture<T>(owner: ContextOwner): DeferredFuture<T>;
-//# sourceMappingURL=future.d.ts.map

package/declarations/request/-private/manager.d.ts

@@ -1,160 +1,162 @@
-import type { StableDocumentIdentifier } from '../../types/identifier';
-import type { RequestInfo } from '../../types/request';
-import type { CacheHandler, Future, GenericCreateArgs, Handler, ManagedRequestPriority } from './types';
-import { IS_CACHE_HANDLER } from './utils';
+import type { StableDocumentIdentifier } from "../../types/identifier.js";
+import type { RequestInfo } from "../../types/request.js";
+import type { CacheHandler, Future, GenericCreateArgs, Handler, ManagedRequestPriority } from "./types.js";
+import { IS_CACHE_HANDLER } from "./utils.js";
 /**
- * ## Import
- *
- * ```js
- * import { RequestManager } from '@warp-drive/core';
- * ```
- *
- * For complete usage guide see the [RequestManager Documentation](/guides/).
- *
- * ## How It Works
- *
- * ```ts
- * interface RequestManager {
- *   request<T>(req: RequestInfo): Future<T>;
- * }
- * ```
- *
- * A RequestManager provides a request/response flow in which configured
- * handlers are successively given the opportunity to handle, modify, or
- * pass-along a request.
- *
- * <img src="/images/handlers-all-labeled.gif" alt="RequestManager Flow Animation" width="100%" />
- *
- * For example:
- *
- * ::: code-group
- *
- * ```ts [Setup.ts]
- * import { RequestManager, Fetch } from '@warp-drive/core';
- * import { AutoCompress } from '@warp-drive/utilities/handlers';
- * import Auth from 'ember-simple-auth/handler';
- *
- * // ... create manager
- * const manager = new RequestManager()
- *    .use([Auth, new AutoCompress(), Fetch]); // [!code focus]
- * ```
- *
- * ```ts [Usage.ts]
- * import Config from './config';
- *
- * const { apiUrl } = Config;
- *
- * // ... execute a request
- * const response = await manager.request({
- *   url: `${apiUrl}/users`
- * });
- * ```
- *
- * :::
- *
- * ### Futures
- *
- * The return value of `manager.request` is a `Future`, which allows
- * access to limited information about the request while it is still
- * pending and fulfills with the final state when the request completes.
- *
- * A `Future` is cancellable via `abort`.
- *
- * Handlers may optionally expose a `ReadableStream` to the `Future` for
- * streaming data; however, when doing so the future should not resolve
- * until the response stream is fully read.
- *
- * ```ts
- * interface Future<T> extends Promise<StructuredDocument<T>> {
- *   abort(): void;
- *
- *   async getStream(): ReadableStream | null;
- * }
- * ```
- *
- * ### StructuredDocuments
- *
- * A Future resolves with a `StructuredDataDocument` or rejects with a `StructuredErrorDocument`.
- *
- * ```ts
- * interface StructuredDataDocument<T> {
- *   request: ImmutableRequestInfo;
- *   response: ImmutableResponseInfo;
- *   content: T;
- * }
- * interface StructuredErrorDocument extends Error {
- *   request: ImmutableRequestInfo;
- *   response: ImmutableResponseInfo;
- *   error: string | object;
- * }
- * type StructuredDocument<T> = StructuredDataDocument<T> | StructuredErrorDocument;
- * ```
- *
- * @class RequestManager
- * @public
- */
+* ## Import
+*
+* ```js
+* import { RequestManager } from '@warp-drive/core';
+* ```
+*
+* For complete usage guide see the [RequestManager Documentation](/guides/).
+*
+* ## How It Works
+*
+* ```ts
+* interface RequestManager {
+*   request<T>(req: RequestInfo): Future<T>;
+* }
+* ```
+*
+* A RequestManager provides a request/response flow in which configured
+* handlers are successively given the opportunity to handle, modify, or
+* pass-along a request.
+*
+* <img src="/images/handlers-all-labeled.gif" alt="RequestManager Flow Animation" width="100%" />
+*
+* For example:
+*
+* ::: code-group
+*
+* ```ts [Setup.ts]
+* import { RequestManager, Fetch } from '@warp-drive/core';
+* import { AutoCompress } from '@warp-drive/utilities/handlers';
+* import Auth from 'ember-simple-auth/handler';
+*
+* // ... create manager
+* const manager = new RequestManager()
+*    .use([Auth, new AutoCompress(), Fetch]); // [!code focus]
+* ```
+*
+* ```ts [Usage.ts]
+* import Config from './config';
+*
+* const { apiUrl } = Config;
+*
+* // ... execute a request
+* const response = await manager.request({
+*   url: `${apiUrl}/users`
+* });
+* ```
+*
+* :::
+*
+* ### Futures
+*
+* The return value of `manager.request` is a `Future`, which allows
+* access to limited information about the request while it is still
+* pending and fulfills with the final state when the request completes.
+*
+* A `Future` is cancellable via `abort`.
+*
+* Handlers may optionally expose a `ReadableStream` to the `Future` for
+* streaming data; however, when doing so the future should not resolve
+* until the response stream is fully read.
+*
+* ```ts
+* interface Future<T> extends Promise<StructuredDocument<T>> {
+*   abort(): void;
+*
+*   async getStream(): ReadableStream | null;
+* }
+* ```
+*
+* ### StructuredDocuments
+*
+* A Future resolves with a `StructuredDataDocument` or rejects with a `StructuredErrorDocument`.
+*
+* ```ts
+* interface StructuredDataDocument<T> {
+*   request: ImmutableRequestInfo;
+*   response: ImmutableResponseInfo;
+*   content: T;
+* }
+* interface StructuredErrorDocument extends Error {
+*   request: ImmutableRequestInfo;
+*   response: ImmutableResponseInfo;
+*   error: string | object;
+* }
+* type StructuredDocument<T> = StructuredDataDocument<T> | StructuredErrorDocument;
+* ```
+*
+* @class RequestManager
+* @public
+*/
 export declare class RequestManager {
-    #private;
-    /** @internal */
-    _hasCacheHandler: boolean;
-    /**
-     * A map of pending requests from request.id to their
-     * associated CacheHandler promise.
-     *
-     * This queue is managed by the CacheHandler
-     *
-     * @internal
-     */
-    _pending: Map<number, Promise<unknown>>;
-    /** @internal */
-    _deduped: Map<StableDocumentIdentifier, {
-        priority: ManagedRequestPriority;
-        promise: Promise<unknown>;
-    }>;
-    constructor(options?: GenericCreateArgs);
-    /**
-     * Register a handler to use for primary cache intercept.
-     *
-     * Only one such handler may exist. If using the same
-     * RequestManager as the Store instance the Store
-     * registers itself as a Cache handler.
-     *
-     * @public
-     */
-    useCache(cacheHandler: CacheHandler & {
-        [IS_CACHE_HANDLER]?: true;
-    }): this;
-    /**
-     * Register handler(s) to use when a request is issued.
-     *
-     * Handlers will be invoked in the order they are registered.
-     * Each Handler is given the opportunity to handle the request,
-     * curry the request, or pass along a modified request.
-     *
-     * @public
-     * @param {Handler[]} newHandlers
-     * @return {ThisType}
-     */
-    use(newHandlers: Handler[]): this;
-    /**
-     * Issue a Request.
-     *
-     * Returns a Future that fulfills with a StructuredDocument
-     *
-     * @public
-     * @param {RequestInfo} request
-     * @return {Future}
-     */
-    request<RT, T = unknown>(request: RequestInfo<RT, T>): Future<RT>;
-    /**
-     * This method exists so that the RequestManager can be created
-     * can be created by container/factory systems that expect to
-     * call a static `create` method to instantiate the class.
-     *
-     * Using `new RequestManager()` directly is preferred.
-     *
-     * @private
-     */
-    static create(options?: GenericCreateArgs): RequestManager;
+	#private;
+	/** @internal */
+	_hasCacheHandler: boolean;
+	/**
+	* A map of pending requests from request.id to their
+	* associated CacheHandler promise.
+	*
+	* This queue is managed by the CacheHandler
+	*
+	* @internal
+	*/
+	_pending: Map<number, Promise<unknown>>;
+	/** @internal */
+	_deduped: Map<StableDocumentIdentifier, {
+		priority: ManagedRequestPriority;
+		promise: Promise<unknown>;
+	}>;
+	constructor(options?: GenericCreateArgs);
+	/**
+	* Register a handler to use for primary cache intercept.
+	*
+	* Only one such handler may exist. If using the same
+	* RequestManager as the Store instance the Store
+	* registers itself as a Cache handler.
+	*
+	* @public
+	*/
+	useCache(cacheHandler: CacheHandler & {
+		[IS_CACHE_HANDLER]?: true;
+	}): this;
+	/**
+	* Register handler(s) to use when a request is issued.
+	*
+	* Handlers will be invoked in the order they are registered.
+	* Each Handler is given the opportunity to handle the request,
+	* curry the request, or pass along a modified request.
+	*
+	* @public
+	* @param {Handler[]} newHandlers
+	* @return {ThisType}
+	*/
+	use(newHandlers: Handler[]): this;
+	/**
+	* Issue a Request.
+	*
+	* Returns a Future that fulfills with a StructuredDocument
+	*
+	* @public
+	* @param {RequestInfo} request
+	* @return {Future}
+	*/
+	request<
+		RT,
+		T = unknown
+	>(request: RequestInfo<RT, T>): Future<RT>;
+	/**
+	* This method exists so that the RequestManager can be created
+	* can be created by container/factory systems that expect to
+	* call a static `create` method to instantiate the class.
+	*
+	* Using `new RequestManager()` directly is preferred.
+	*
+	* @private
+	*/
+	static create(options?: GenericCreateArgs): RequestManager;
 }
-//# sourceMappingURL=manager.d.ts.map

package/declarations/request/-private/promise-cache.d.ts

@@ -1,20 +1,28 @@
-export type CacheResult<T = unknown, E = unknown> = {
-    isError: true;
-    result: E;
+export type CacheResult<
+	T = unknown,
+	E = unknown
+> = {
+	isError: true;
+	result: E;
 } | {
-    isError: false;
-    result: T;
+	isError: false;
+	result: T;
 };
-export type Awaitable<T = unknown, E = unknown> = {
-    then: (onFulfilled: (value: T) => unknown, onRejected: (reason: E) => unknown) => unknown;
-    catch: (onRejected: (reason: E) => unknown) => unknown;
-    finally: (onFinally: () => unknown) => unknown;
+export type Awaitable<
+	T = unknown,
+	E = unknown
+> = {
+	then: (onFulfilled: (value: T) => unknown, onRejected: (reason: E) => unknown) => unknown;
+	catch: (onRejected: (reason: E) => unknown) => unknown;
+	finally: (onFinally: () => unknown) => unknown;
 };
-export declare const PromiseCache: WeakMap<Awaitable<unknown, unknown>, CacheResult<unknown, unknown>>;
-export declare const RequestMap: Map<number, CacheResult<unknown, unknown>>;
+export declare const PromiseCache: WeakMap<Awaitable, CacheResult>;
+export declare const RequestMap: Map<number, CacheResult>;
 export declare function setRequestResult(requestId: number, result: CacheResult): void;
 export declare function clearRequestResult(requestId: number): void;
 export declare function getRequestResult(requestId: number): CacheResult | undefined;
 export declare function setPromiseResult(promise: Promise<unknown> | Awaitable, result: CacheResult): void;
-export declare function getPromiseResult<T, E>(promise: Promise<T> | Awaitable<T, E>): CacheResult<T, E> | undefined;
-//# sourceMappingURL=promise-cache.d.ts.map
+export declare function getPromiseResult<
+	T,
+	E
+>(promise: Promise<T> | Awaitable<T, E>): CacheResult<T, E> | undefined;