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

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

@@ -1,90 +1,91 @@
-import type { StableDocumentIdentifier } from '../../types/identifier';
-import type { IS_FUTURE, RequestContext, RequestInfo, ResponseInfo, StructuredDataDocument } from '../../types/request';
+/* eslint-disable no-irregular-whitespace */
+import type { StableDocumentIdentifier } from "../../types/identifier.js";
+import type { IS_FUTURE, RequestContext, RequestInfo, ResponseInfo, StructuredDataDocument } from "../../types/request.js";
 export interface GodContext {
-    controller: AbortController;
-    response: ResponseInfo | null;
-    stream: ReadableStream | Promise<ReadableStream | null> | null;
-    hasRequestedStream: boolean;
-    id: number;
-    identifier: StableDocumentIdentifier | null;
+	controller: AbortController;
+	response: ResponseInfo | null;
+	stream: ReadableStream | Promise<ReadableStream | null> | null;
+	hasRequestedStream: boolean;
+	id: number;
+	identifier: StableDocumentIdentifier | null;
 }
 export type Deferred<T> = {
-    resolve(v: T): void;
-    reject(v: unknown): void;
-    promise: Promise<T>;
+	resolve(v: T): void;
+	reject(v: unknown): void;
+	promise: Promise<T>;
 };
 export type ManagedRequestPriority = {
-    blocking: boolean;
+	blocking: boolean;
 };
 export type DeferredStream = {
-    resolve(v: ReadableStream | null): void;
-    reject(v: unknown): void;
-    promise: Promise<ReadableStream | null> & {
-        sizeHint?: number;
-    };
+	resolve(v: ReadableStream | null): void;
+	reject(v: unknown): void;
+	promise: Promise<ReadableStream | null> & {
+		sizeHint?: number;
+	};
 };
 /**
- * A Future is a {@link Promise} which resolves to a {@link StructuredDataDocument | StructuredDocument}
- * while providing the ability to {@link Future.abort | abort} the underlying request, and
- * {@link Future.getStream | access the response stream} before the outer promise resolves;
- *
- * @public
- */
+* A Future is a {@link Promise} which resolves to a {@link StructuredDataDocument | StructuredDocument}
+* while providing the ability to {@link Future.abort | abort} the underlying request, and
+* {@link Future.getStream | access the response stream} before the outer promise resolves;
+*
+* @public
+*/
 export interface Future<T> extends Promise<StructuredDataDocument<T>> {
-    [IS_FUTURE]: true;
-    /**
-     * Cancel this request by firing the {@link AbortController}'s signal.
-     *
-     * @privateRemarks
-     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AbortController/abort)
-     *
-     * @param reason optional reason for aborting the request
-     * @public
-     */
-    abort(reason?: string): void;
-    /**
-     * Get the response stream, if any, once made available.
-     *
-     * @public
-     * @return {Promise<ReadableStream | null>}
-     */
-    getStream(): Promise<ReadableStream | null>;
-    /**
-     *  Run a callback when this request completes. Use sparingly,
-     *  mostly useful for instrumentation and infrastructure.
-     *
-     * @param cb the callback to run
-     * @public
-     * @return {void}
-     */
-    onFinalize(cb: () => void): void;
-    /**
-     * The identifier of the associated request, if any, as
-     * assigned by the CacheHandler.
-     *
-     * @property lid
-     * @type {StableDocumentIdentifier | null}
-     * @public
-     */
-    lid: StableDocumentIdentifier | null;
-    /**
-     * The id of the associated request, if any, as assigned
-     * by the RequestManager
-     *
-     * @property id
-     * @type {Number}
-     * @public
-     */
-    id: number;
+	[IS_FUTURE]: true;
+	/**
+	* Cancel this request by firing the {@link AbortController}'s signal.
+	*
+	* @privateRemarks
+	* [MDN Reference](https://developer.mozilla.org/docs/Web/API/AbortController/abort)
+	*
+	* @param reason optional reason for aborting the request
+	* @public
+	*/
+	abort(reason?: string): void;
+	/**
+	* Get the response stream, if any, once made available.
+	*
+	* @public
+	* @return {Promise<ReadableStream | null>}
+	*/
+	getStream(): Promise<ReadableStream | null>;
+	/**
+	*  Run a callback when this request completes. Use sparingly,
+	*  mostly useful for instrumentation and infrastructure.
+	*
+	* @param cb the callback to run
+	* @public
+	* @return {void}
+	*/
+	onFinalize(cb: () => void): void;
+	/**
+	* The identifier of the associated request, if any, as
+	* assigned by the CacheHandler.
+	*
+	* @property lid
+	* @type {StableDocumentIdentifier | null}
+	* @public
+	*/
+	lid: StableDocumentIdentifier | null;
+	/**
+	* The id of the associated request, if any, as assigned
+	* by the RequestManager
+	*
+	* @property id
+	* @type {Number}
+	* @public
+	*/
+	id: number;
 }
 export type DeferredFuture<T> = {
-    resolve(v: StructuredDataDocument<T>): void;
-    reject(v: unknown): void;
-    promise: Future<T>;
+	resolve(v: StructuredDataDocument<T>): void;
+	reject(v: unknown): void;
+	promise: Future<T>;
 };
 export type NextFn<P = unknown> = (req: RequestInfo) => Future<P>;
 /**
- * Requests are fulfilled by handlers. A handler receives the request context
+* Requests are fulfilled by handlers. A handler receives the request context
 as well as a `next` function with which to pass along a request to the next
 handler if it so chooses.
 
@@ -98,7 +99,7 @@ that it can then compose how it sees fit with its own response.
 type NextFn<P> = (req: RequestInfo) => Future<P>;
 
 interface Handler {
-  async request<T>(context: RequestContext, next: NextFn<P>): T;
+async request<T>(context: RequestContext, next: NextFn<P>): T;
 }
 ```
 
@@ -106,10 +107,10 @@ interface Handler {
 
 ```ts
 interface RequestContext<T> {
-  readonly request: RequestInfo;
+readonly request: RequestInfo;
 
-  setStream(stream: ReadableStream | Promise<ReadableStream>): void;
-  setResponse(response: Response | ResponseInfo): void;
+setStream(stream: ReadableStream | Promise<ReadableStream>): void;
+setResponse(response: Response | ResponseInfo): void;
 }
 ```
 
@@ -122,13 +123,13 @@ response content before passing along the chunk downstream.
 
 ```ts
 const FetchHandler = {
-  async request(context) {
-    const response = await fetch(context.request);
-    context.setResponse(reponse);
-    context.setStream(response.clone().body);
+async request(context) {
+const response = await fetch(context.request);
+context.setResponse(reponse);
+context.setStream(response.clone().body);
 
-    return response.json();
-  }
+return response.json();
+}
 }
 ```
 
@@ -139,13 +140,13 @@ const FetchHandler = {
 For context, it helps to understand a few of the use-cases that RequestManager
 is intended to allow.
 
- - to manage and return streaming content (such as video files)
- - to fulfill a request from multiple sources or by splitting one request into multiple requests
-   - for instance one API call for a user and another for the user's friends
-   - or e.g. fulfilling part of the request from one source (one API, in-memory, localStorage, IndexedDB etc.) and the rest from another source (a different API, a WebWorker, etc.)
- - to coalesce multiple requests
- - to decorate a request with additional info
-   - e.g. an Auth handler that ensures the correct tokens or headers or cookies are attached.
+- to manage and return streaming content (such as video files)
+- to fulfill a request from multiple sources or by splitting one request into multiple requests
+- for instance one API call for a user and another for the user's friends
+- or e.g. fulfilling part of the request from one source (one API, in-memory, localStorage, IndexedDB etc.) and the rest from another source (a different API, a WebWorker, etc.)
+- to coalesce multiple requests
+- to decorate a request with additional info
+- e.g. an Auth handler that ensures the correct tokens or headers or cookies are attached.
 
 ----
 
@@ -185,52 +186,51 @@ Request handlers are registered by configuring the manager via `use`
 
 ```ts
 const manager = new RequestManager()
-  .use([Handler1, Handler2]);
+.use([Handler1, Handler2]);
 ```
 
 Handlers will be invoked in the order they are registered ("fifo", first-in first-out), and may only be registered up until the first request is made. It is recommended but not required to register all handlers at one time in order to ensure explicitly visible handler ordering.
 
 
- @class (Interface) Handler
- @public
+@class (Interface) Handler
+@public
 */
 export interface Handler {
-    /**
-     * Method to implement to handle requests. Receives the request
-     * context and a nextFn to call to pass-along the request to
-     * other handlers.
-     *
-     * @public
-     * @param context
-     * @param next
-     */
-    request<T = unknown>(context: RequestContext, next: NextFn<T>): Promise<T | StructuredDataDocument<T>> | Future<T>;
+	/**
+	* Method to implement to handle requests. Receives the request
+	* context and a nextFn to call to pass-along the request to
+	* other handlers.
+	*
+	* @public
+	* @param context
+	* @param next
+	*/
+	request<T = unknown>(context: RequestContext, next: NextFn<T>): Promise<T | StructuredDataDocument<T>> | Future<T>;
 }
 /**
- * The CacheHandler is identical to other handlers ecxept that it
- * is allowed to return a value synchronously. This is useful for
- * features like reducing microtask queueing when de-duping.
- *
- * A RequestManager may only have one CacheHandler, registered via
- * `manager.useCache(CacheHandler)`.
- *
- * @class (Interface) CacheHandler
- * @public
- */
+* The CacheHandler is identical to other handlers ecxept that it
+* is allowed to return a value synchronously. This is useful for
+* features like reducing microtask queueing when de-duping.
+*
+* A RequestManager may only have one CacheHandler, registered via
+* `manager.useCache(CacheHandler)`.
+*
+* @class (Interface) CacheHandler
+* @public
+*/
 export interface CacheHandler {
-    /**
-     * Method to implement to handle requests. Receives the request
-     * context and a nextFn to call to pass-along the request to
-     * other handlers.
-     *
-     * @public
-     * @param context
-     * @param next
-     */
-    request<T = unknown>(context: RequestContext, next: NextFn<T>): Promise<T | StructuredDataDocument<T>> | Future<T> | T;
+	/**
+	* Method to implement to handle requests. Receives the request
+	* context and a nextFn to call to pass-along the request to
+	* other handlers.
+	*
+	* @public
+	* @param context
+	* @param next
+	*/
+	request<T = unknown>(context: RequestContext, next: NextFn<T>): Promise<T | StructuredDataDocument<T>> | Future<T> | T;
 }
 export interface RequestResponse<T> {
-    result: T;
+	result: T;
 }
 export type GenericCreateArgs = Record<string | symbol, unknown>;
-//# sourceMappingURL=types.d.ts.map

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

@@ -1,16 +1,15 @@
-import type { RequestInfo, StructuredDataDocument } from '../../types/request';
-import { ContextOwner } from './context';
-import type { DeferredFuture, Future, GodContext, Handler } from './types';
+import type { RequestInfo, StructuredDataDocument } from "../../types/request.js";
+import { ContextOwner } from "./context.js";
+import type { DeferredFuture, Future, GodContext, Handler } from "./types.js";
 export declare const IS_CACHE_HANDLER: "___(unique) Symbol(IS_CACHE_HANDLER)";
 export declare function curryFuture<T>(owner: ContextOwner, inbound: Future<T>, outbound: DeferredFuture<T>): Future<T>;
 export interface HttpErrorProps extends DOMException {
-    code: number;
-    name: string;
-    status: number;
-    statusText: string;
-    isRequestError: boolean;
+	code: number;
+	name: string;
+	status: number;
+	statusText: string;
+	isRequestError: boolean;
 }
 export declare function enhanceReason(reason?: string): DOMException;
 export declare function handleOutcome<T>(owner: ContextOwner, inbound: Promise<T | StructuredDataDocument<T>>, outbound: DeferredFuture<T>): Future<T>;
 export declare function executeNextHandler<T>(wares: Readonly<Handler[]>, request: RequestInfo, i: number, god: GodContext): Future<T>;
-//# sourceMappingURL=utils.d.ts.map

package/declarations/request.d.ts

@@ -1,6 +1,5 @@
-export { createDeferred } from './request/-private/future.ts';
-export type { Future, Handler, CacheHandler, NextFn, Deferred, ManagedRequestPriority, } from './request/-private/types.ts';
-export { setPromiseResult, getPromiseResult } from './request/-private/promise-cache.ts';
-export type { Awaitable } from './request/-private/promise-cache.ts';
-export type { Context } from './request/-private/context.ts';
-//# sourceMappingURL=request.d.ts.map
+export { createDeferred } from "./request/-private/future.js";
+export type { Future, Handler, CacheHandler, NextFn, Deferred, ManagedRequestPriority } from "./request/-private/types.js";
+export { setPromiseResult, getPromiseResult } from "./request/-private/promise-cache.js";
+export type { Awaitable } from "./request/-private/promise-cache.js";
+export type { Context } from "./request/-private/context.js";

package/declarations/store/-private/cache-handler/handler.d.ts

@@ -1,57 +1,62 @@
-import type { CacheHandler as CacheHandlerType } from '../../../request.ts';
-import type { ImmutableRequestInfo, RequestContext } from '../../../types/request.ts';
-import type { ResourceIdentifierObject } from '../../../types/spec/json-api-raw.ts';
-import type { RequestSignature } from '../../../types/symbols.ts';
-import type { Store } from '../store-service.ts';
-export type LooseStoreRequestInfo<RT = unknown, T = unknown> = Omit<ImmutableRequestInfo<RT, T>, 'records' | 'headers' | typeof RequestSignature> & {
-    records?: ResourceIdentifierObject[];
-    headers?: Headers;
+import type { CacheHandler as CacheHandlerType } from "../../../request.js";
+import type { ImmutableRequestInfo, RequestContext } from "../../../types/request.js";
+import type { ResourceIdentifierObject } from "../../../types/spec/json-api-raw.js";
+import type { RequestSignature } from "../../../types/symbols.js";
+import type { Store } from "../store-service.js";
+export type LooseStoreRequestInfo<
+	RT = unknown,
+	T = unknown
+> = Omit<ImmutableRequestInfo<RT, T>, "records" | "headers" | typeof RequestSignature> & {
+	records?: ResourceIdentifierObject[];
+	headers?: Headers;
 };
-export type StoreRequestInput<RT = unknown, T = unknown> = ImmutableRequestInfo<RT, T> | LooseStoreRequestInfo<RT, T>;
+export type StoreRequestInput<
+	RT = unknown,
+	T = unknown
+> = ImmutableRequestInfo<RT, T> | LooseStoreRequestInfo<RT, T>;
 export interface StoreRequestContext extends RequestContext {
-    request: ImmutableRequestInfo & {
-        store: Store;
-    };
+	request: ImmutableRequestInfo & {
+		store: Store;
+	};
 }
 /**
- * A CacheHandler that adds support for using an WarpDrive Cache with a RequestManager.
- *
- * This handler will only run when a request has supplied a `store` instance. Requests
- * issued by the store via `store.request()` will automatically have the `store` instance
- * attached to the request.
- *
- * ```ts
- * requestManager.request({
- *   store: store,
- *   url: '/api/posts',
- *   method: 'GET'
- * });
- * ```
- *
- * When this handler elects to handle a request, it will return the raw `StructuredDocument`
- * unless the request has `[EnableHydration]` set to `true`. In this case, the handler will
- * return a `Document` instance that will automatically update the UI when the cache is updated
- * in the future and will hydrate any identifiers in the StructuredDocument into Record instances.
- *
- * When issuing a request via the store, [EnableHydration] is automatically set to `true`. This
- * means that if desired you can issue requests that utilize the cache without needing to also
- * utilize Record instances if desired.
- *
- * Said differently, you could elect to issue all requests via a RequestManager, without ever using
- * the store directly, by setting [EnableHydration] to `true` and providing a store instance. Not
- * necessarily the most useful thing, but the decoupled nature of the RequestManager and incremental-feature
- * approach of WarpDrive allows for this flexibility.
- *
- * ```ts
- * import { EnableHydration } from '@warp-drive/core/types/request';
- *
- * requestManager.request({
- *   store: store,
- *   url: '/api/posts',
- *   method: 'GET',
- *   [EnableHydration]: true
- * });
- *
- */
+* A CacheHandler that adds support for using an WarpDrive Cache with a RequestManager.
+*
+* This handler will only run when a request has supplied a `store` instance. Requests
+* issued by the store via `store.request()` will automatically have the `store` instance
+* attached to the request.
+*
+* ```ts
+* requestManager.request({
+*   store: store,
+*   url: '/api/posts',
+*   method: 'GET'
+* });
+* ```
+*
+* When this handler elects to handle a request, it will return the raw `StructuredDocument`
+* unless the request has `[EnableHydration]` set to `true`. In this case, the handler will
+* return a `Document` instance that will automatically update the UI when the cache is updated
+* in the future and will hydrate any identifiers in the StructuredDocument into Record instances.
+*
+* When issuing a request via the store, [EnableHydration] is automatically set to `true`. This
+* means that if desired you can issue requests that utilize the cache without needing to also
+* utilize Record instances if desired.
+*
+* Said differently, you could elect to issue all requests via a RequestManager, without ever using
+* the store directly, by setting [EnableHydration] to `true` and providing a store instance. Not
+* necessarily the most useful thing, but the decoupled nature of the RequestManager and incremental-feature
+* approach of WarpDrive allows for this flexibility.
+*
+* ```ts
+* import { EnableHydration } from '@warp-drive/core/types/request';
+*
+* requestManager.request({
+*   store: store,
+*   url: '/api/posts',
+*   method: 'GET',
+*   [EnableHydration]: true
+* });
+*
+*/
 export declare const CacheHandler: CacheHandlerType;
-//# sourceMappingURL=handler.d.ts.map