@warp-drive/core 5.7.0-alpha.13 → 5.7.0-alpha.14

package/declarations/store/-private/record-arrays/legacy-query.d.ts

@@ -0,0 +1,103 @@
+import type { ImmutableRequestInfo } from "../../../types/request.js";
+import type { Links, Meta, PaginationLinks } from "../../../types/spec/json-api-raw.js";
+import type { LegacyLiveArray, LegacyLiveArrayCreateOptions } from "./legacy-live-array.js";
+/**
+* QueryArrays contain the primary records returned when querying
+* for records by `ResourceType`.
+*
+* ### Basic Example
+*
+* For instance, if an application were to have a `'user'` type:
+*
+* ```ts
+* const users = await store.query('user', { name: 'Chris' });
+* ```
+*
+* ---
+*
+*  
+*
+* ### QueryArrays are Arrays
+*
+* QueryArrays have all array APIs, and will report `true`
+* for both `queryArray instanceof Array` and `Array.isArray(queryArray)`
+*
+* However, any mutation of the array will throw an error.
+*
+* ---
+*
+*  
+*
+* ### Reactive
+*
+* If a record in a QueryArray is deleted and unloaded, it will be
+* automatically removed from the array.
+*
+* ---
+*
+*  
+*
+* ### Immutable
+*
+* Records cannot be directly added to or removed from a QueryArray.
+*
+* ---
+*
+*  
+*
+* ### Polymorphism
+*
+* QueryArrays are not intended to be polymorphic. If your application has
+* an abstract type "car" with concrete types "ferrari" and "bmw", a query
+* which returns primary data containing both ferraris and bmws will *likely*
+* work, but it is not guaranteed.
+*
+* In contrast, the {@link ReactiveResourceArray} returned when using {@link Store.request}
+* is guaranteed to work with polymorphic responses.
+*
+* ---
+*
+*  
+*
+* ### Memory Leaks
+*
+* QueryArrays are meant to be long lived. They can be refreshed using
+* `array.update()`, and destroyed via `array.destroy()`.
+*
+* Unlike most Reactive state in WarpDrive, applications must choose to call
+* `destroy` when the `QueryArray` is no longer needed, else the array instance
+* will be retained until either the application or the store which created it
+* are destroyed. Destroying a QueryArray does not remove its records
+* from the cache, but it does remove the array as well as the overhead it requires
+* from the store for book-keeping.
+*
+* @legacy we recommend againt using QueryArrays. Use {@link Store.request} instead
+*/
+export interface LegacyQueryArray<T = unknown> extends LegacyLiveArray<T> {
+	query: ImmutableRequestInfo | Record<string, unknown> | null;
+	destroy(): void;
+	links: PaginationLinks | Links | null;
+	meta: Meta | null;
+}
+/**
+* The options for {@link createLegacyQueryArray}
+*
+* See also {@link LegacyLiveArrayCreateOptions} which
+* this extends.
+*
+* @internal
+*/
+export interface LegacyQueryArrayCreateOptions extends LegacyLiveArrayCreateOptions {
+	query: ImmutableRequestInfo | Record<string, unknown> | null;
+	isLoaded: boolean;
+	links: PaginationLinks | Links | null;
+	meta: Meta | null;
+}
+/**
+* Creates a {@link LegacyQueryArray}
+*
+* Options: {@link LegacyQueryArrayCreateOptions}
+*
+* @internal
+*/
+export declare function createLegacyQueryArray<T = unknown>(options: LegacyQueryArrayCreateOptions): LegacyQueryArray<T>;

package/declarations/store/-private/record-arrays/resource-array.d.ts

@@ -0,0 +1,82 @@
+import type { ExtensionDef } from "../../../reactive.js";
+import { Context } from "../../../reactive/-private.js";
+import type { StableDocumentIdentifier, StableRecordIdentifier } from "../../../types/identifier.js";
+import type { ObjectValue } from "../../../types/json/raw.js";
+import type { CollectionField } from "../../../types/schema/fields.js";
+import type { SignalStore, WarpDriveSignal } from "../new-core-tmp/reactivity/internal.js";
+import type { Store } from "../store-service.js";
+import type { KeyType, MinimumManager } from "./-utils.js";
+import { NativeProxy } from "./native-proxy-type-fix.js";
+declare const IS_COLLECTION: "___(unique) Symbol(IS_COLLECTION)";
+type ProxiedMethod = (...args: unknown[]) => unknown;
+interface ReactiveResourceArrayCreateOptions {
+	// passed in
+	store: Store;
+	manager: MinimumManager;
+	editable: boolean;
+	source: StableRecordIdentifier[];
+	// reactive, passed in
+	data: ObjectValue | null;
+	// non-reactive, passed in
+	features: Record<string | symbol, unknown> | null;
+	extensions: Map<string | symbol, ExtensionDef> | null;
+	// not-accessible except by the context
+	options: Record<string, unknown> | null;
+	destroy: null | ((this: ReactiveResourceArray, clear: boolean) => void);
+	mutate: null | ((target: StableRecordIdentifier[], receiver: typeof NativeProxy<StableRecordIdentifier[], unknown[]>, prop: string, args: unknown[], _SIGNAL: WarpDriveSignal) => unknown);
+}
+interface ReactiveResourceArrayContext extends ReactiveResourceArrayCreateOptions {
+	destroy: (this: ReactiveResourceArray, clear: boolean) => void;
+	mutate: (target: StableRecordIdentifier[], receiver: typeof NativeProxy<StableRecordIdentifier[], unknown[]>, prop: string, args: unknown[], _SIGNAL: WarpDriveSignal) => unknown;
+	// generated
+	signals: SignalStore;
+	signal: WarpDriveSignal;
+	isDestroying: boolean;
+	isDestroyed: boolean;
+	transaction: boolean;
+	boundFns: Map<KeyType, ProxiedMethod>;
+}
+export interface ReactiveResourceArray<T = unknown> extends Omit<Array<T>, "[]"> {
+	/** @internal */
+	isDestroying: boolean;
+	/** @internal */
+	isDestroyed: boolean;
+	/** @internal */
+	destroy: (this: ReactiveResourceArray, clear: boolean) => void;
+	/** @internal */
+	[IS_COLLECTION]: boolean;
+	/** @internal */
+	[Context]: ReactiveResourceArrayContext;
+}
+export interface TargetArray extends Array<StableRecordIdentifier> {
+	/** @internal */
+	[Context]: ReactiveResourceArrayContext;
+}
+export declare function createReactiveResourceArray<T>(options: ReactiveResourceArrayCreateOptions): ReactiveResourceArray<T>;
+export declare function destroy(this: ReactiveResourceArray, clear: boolean): void;
+export interface ReactiveRequestCollectionCreateArgs {
+	// passed in
+	store: Store;
+	manager: MinimumManager;
+	source: StableRecordIdentifier[];
+	options: {
+		requestKey: StableDocumentIdentifier;
+	} | null;
+}
+export declare function createRequestCollection(config: ReactiveRequestCollectionCreateArgs): ReactiveResourceArray;
+export interface ReactiveRelatedCollectionCreateArgs {
+	// passed in
+	store: Store;
+	manager: MinimumManager;
+	source: StableRecordIdentifier[];
+	// not-accessible except by the context
+	options: {
+		resourceKey: StableRecordIdentifier;
+		path: string[];
+		field: CollectionField;
+	};
+	editable: boolean;
+	extensions: Map<string | symbol, ExtensionDef> | null;
+}
+export declare function createRelatedCollection(config: ReactiveRelatedCollectionCreateArgs): ReactiveResourceArray;
+export {};

package/declarations/store/-private/store-service.d.ts

@@ -16,7 +16,7 @@ import { InstanceCache, storeFor } from "./caches/instance-cache.js";
 import NotificationManager from "./managers/notification-manager.js";
 import { RecordArrayManager } from "./managers/record-array-manager.js";
 import { RequestStateService } from "./network/request-cache.js";
-import type { IdentifierArray } from "./record-arrays/identifier-array.js";
+import type { LegacyLiveArray } from "./record-arrays/legacy-live-array.js";
 export { storeFor };
 // We inline this list of methods to avoid importing EmberObject
 type EmberObjectKey = "_debugContainerKey" | "_super" | "addObserver" | "cacheFor" | "concatenatedProperties" | "decrementProperty" | "destroy" | "get" | "getProperties" | "incrementProperty" | "init" | "isDestroyed" | "isDestroying" | "mergedProperties" | "notifyPropertyChange" | "removeObserver" | "reopen" | "set" | "setProperties" | "toggleProperty" | "toString" | "willDestroy";
@@ -687,8 +687,8 @@ export declare class Store extends BaseClass {
 	@param {String} type the name of the resource
 	@return {RecordArray}
 	*/
-	peekAll<T>(type: TypeFromInstance<T>): IdentifierArray<T>;
-	peekAll(type: string): IdentifierArray;
+	peekAll<T>(type: TypeFromInstance<T>): LegacyLiveArray<T>;
+	peekAll(type: string): LegacyLiveArray;
 	/**
 	This method unloads all records in the store.
 	It schedules unloading to happen during the next run loop.

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

@@ -12,7 +12,9 @@ export type { CreateRecordProperties } from "./-private/store-service.js";
 // to also eliminate
 export { coerceId, ensureStringId } from "./-private/utils/coerce-id.js";
 export type { NativeProxy } from "./-private/record-arrays/native-proxy-type-fix.js";
-export { IdentifierArray as LiveArray, Collection as CollectionRecordArray, SOURCE, MUTATE } from "./-private/record-arrays/identifier-array.js";
+export { type ReactiveResourceArray } from "./-private/record-arrays/resource-array.js";
+export { type LegacyLiveArray, type LegacyLiveArray as LiveArray } from "./-private/record-arrays/legacy-live-array.js";
+export { type LegacyQueryArray, type LegacyQueryArray as CollectionRecordArray } from "./-private/record-arrays/legacy-query.js";
 export { RecordArrayManager, fastPush } from "./-private/managers/record-array-manager.js";
 // leaked for private use / test use, should investigate removing
 export { _clearCaches } from "./-private/caches/instance-cache.js";
@@ -20,7 +22,7 @@ export { _clearCaches } from "./-private/caches/instance-cache.js";
 export { setRecordIdentifier, StoreMap } from "./-private/caches/instance-cache.js";
 export { normalizeModelName as _deprecatingNormalize } from "./-private/utils/normalize-model-name.js";
 export type { StoreRequestInput } from "./-private/cache-handler/handler.js";
-export { RelatedCollection } from "./-private/record-arrays/many-array.js";
+export { type LegacyManyArray, type LegacyManyArray as RelatedCollection, createLegacyManyArray } from "./-private/record-arrays/legacy-many-array.js";
 export { log, logGroup } from "./-private/debug/utils.js";
 export { getPromiseState, type PromiseState } from "./-private/new-core-tmp/promise-state.js";
 export { DISPOSE, createRequestSubscription, type SubscriptionArgs, type RequestSubscription } from "./-private/new-core-tmp/request-subscription.js";

package/declarations/store/deprecated/store.d.ts

@@ -1,6 +1,6 @@
 import type { TypeFromInstance } from "../../types/record.js";
 import type { ResourceIdentifierObject } from "../../types/spec/json-api-raw.js";
-import type { CollectionRecordArray, LiveArray } from "../-private.js";
+import type { LegacyLiveArray, LegacyQueryArray } from "../-private.js";
 import { Store } from "../-private/store-service.js";
 import type { FindAllOptions, FindRecordOptions, LegacyResourceQuery, ModelSchema, QueryOptions } from "./-private.js";
 import { RecordReference } from "./-private.js";
@@ -548,9 +548,9 @@ declare module "../-private/store-service" {
 		@param type the name of the resource
 		@param options
 		*/
-		findAll<T>(type: TypeFromInstance<T>, options?: FindAllOptions): Promise<LiveArray<T>>;
+		findAll<T>(type: TypeFromInstance<T>, options?: FindAllOptions): Promise<LegacyLiveArray<T>>;
 		/** @deprecated */
-		findAll(type: string, options?: FindAllOptions): Promise<LiveArray>;
+		findAll(type: string, options?: FindAllOptions): Promise<LegacyLiveArray>;
 		/**
 		This method delegates a query to the adapter. This is the one place where
 		adapter-level semantics are exposed to the application.
@@ -565,13 +565,13 @@ declare module "../-private/store-service" {
 		
 		If you do something like this:
 		
-		```javascript
+		```js
 		store.query('person', { page: 1 });
 		```
 		
 		The request made to the server will look something like this:
 		
-		```
+		```http
 		GET "/api/v1/person?page=1"
 		```
 		
@@ -591,8 +591,7 @@ declare module "../-private/store-service" {
 		```
 		
 		This method returns a promise, which is resolved with a
-		[`Collection`](/ember-data/release/classes/Collection)
-		once the server returns.
+		{@link LegacyQueryArray} once the server returns.
 		
 		@public
 		@deprecated use {@link Store.request} instead
@@ -602,9 +601,9 @@ declare module "../-private/store-service" {
 		@param query a query to be used by the adapter
 		@param options optional, may include `adapterOptions` hash which will be passed to adapter.query
 		*/
-		query<T>(type: TypeFromInstance<T>, query: LegacyResourceQuery, options?: QueryOptions): Promise<CollectionRecordArray<T>>;
+		query<T>(type: TypeFromInstance<T>, query: LegacyResourceQuery, options?: QueryOptions): Promise<LegacyQueryArray<T>>;
 		/** @deprecated */
-		query(type: string, query: LegacyResourceQuery, options?: QueryOptions): Promise<CollectionRecordArray>;
+		query(type: string, query: LegacyResourceQuery, options?: QueryOptions): Promise<LegacyQueryArray>;
 		/**
 		This method makes a request for one record, where the `id` is not known
 		beforehand (if the `id` is known, use [`findRecord`](../methods/findRecord?anchor=findRecord)

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

@@ -1,7 +1,7 @@
 type UniversalTransientKey = "REQ_ID";
 type UniversalKey = `(transient) ${UniversalTransientKey}` | "RequestMap" | "PromiseCache" | "RequestCache" | "SkipCache" | "EnableHydration" | "WarpDriveRuntimeConfig";
 type TransientKey = "transactionRef" | "configuredGenerationMethod" | "configuredUpdateMethod" | "configuredForgetMethod" | "configuredResetMethod" | "configuredKeyInfoMethod" | "signalHooks";
-type GlobalKey = `(transient) ${TransientKey}` | "AdapterError" | "InvalidError" | "TimeoutError" | "AbortError" | "UnauthorizedError" | "ForbiddenError" | "NotFoundError" | "ConflictError" | "ServerError" | "#{}" | "#[]" | "Signals" | "AvailableShims" | "FAKE_ARR" | "#source" | "#update" | "#notify" | "IS_COLLECTION" | "Touching" | "RequestPromise" | "SaveOp" | "LEGACY_SUPPORT" | "LegacySupport" | "Graphs" | "IS_FROZEN" | "IS_CACHE_HANDLER" | "CONFIG" | "DEBUG_MAP" | "IDENTIFIERS" | "DOCUMENTS" | "RecordCache" | "StoreMap" | "Store" | "$type" | "TransformName" | "RequestSignature" | "IS_FUTURE" | "DOC" | "ManagedArrayMap" | "ManagedObjectMap" | "Support" | "SOURCE" | "MUTATE" | "Destroy" | "Checkout" | "Context";
+type GlobalKey = `(transient) ${TransientKey}` | "AdapterError" | "InvalidError" | "TimeoutError" | "AbortError" | "UnauthorizedError" | "ForbiddenError" | "NotFoundError" | "ConflictError" | "ServerError" | "#{}" | "#[]" | "Signals" | "AvailableShims" | "FAKE_ARR" | "#source" | "#update" | "#notify" | "IS_COLLECTION" | "Touching" | "RequestPromise" | "SaveOp" | "LEGACY_SUPPORT" | "LegacySupport" | "Graphs" | "IS_FROZEN" | "IS_CACHE_HANDLER" | "CONFIG" | "DEBUG_MAP" | "IDENTIFIERS" | "DOCUMENTS" | "RecordCache" | "StoreMap" | "Store" | "$type" | "TransformName" | "RequestSignature" | "IS_FUTURE" | "DOC" | "ManagedArrayMap" | "ManagedObjectMap" | "Support" | "SOURCE" | "Destroy" | "Checkout" | "Context";
 type UniqueSymbol<T extends string> = `___(unique) Symbol(${T})`;
 type UniqueSymbolOr<
 	T,

package/declarations/types/cache/operations.d.ts

@@ -2,54 +2,106 @@ import type { StableDocumentIdentifier, StableExistingRecordIdentifier, StableRe
 import type { Value } from "../json/raw.js";
 import type { ExistingResourceObject } from "../spec/json-api-raw.js";
 import type { Relationship } from "./relationship.js";
+/**
+* All operations are objects with at least one property,
+* `op` which contains a string with the name of the operation
+* to perform.
+*/
 export interface Op {
+	/**
+	* The name of the {@link Op | operation}
+	*/
 	op: string;
 }
-// Occasionally the IdentifierCache
-// discovers that two previously thought
-// to be distinct Identifiers refer to
-// the same ResourceBlob. This Operation
-// will be performed giving the Cache the
-// change to cleanup and merge internal
-// state as desired when this discovery
-// is made.
+/**
+* Occasionally the Store discovers that two previously
+* thought to be distinct resources refer to the same resource.
+*
+* This operation will be performed, giving the Cache the chance
+* to cleanup and merge internal state as desired when this discovery
+* is made.
+*/
 export interface MergeOperation extends Op {
 	op: "mergeIdentifiers";
-	// existing
+	/**
+	* The stale {@link StableRecordIdentifier | ResourceKey} that
+	* the cache should eliminate in favor of {@link MergeOperation.value | value}
+	*/
 	record: StableRecordIdentifier;
-	// new
+	/**
+	* The kept {@link StableRecordIdentifier | ResourceKey} that
+	* the cache should also keep and merge {@link MergeOperation.record | record} into.
+	*/
 	value: StableRecordIdentifier;
 }
+/**
+* Removes a document and its associated request from
+* the cache.
+*/
 export interface RemoveDocumentOperation extends Op {
 	op: "remove";
+	/**
+	* The cache key for the request
+	*/
 	record: StableDocumentIdentifier;
 }
+/**
+* Removes a resource from the cache. This is treated
+* as if a remote deletion has occurred, and all references
+* to the resource should be eliminated.
+*/
 export interface RemoveResourceOperation extends Op {
 	op: "remove";
+	/**
+	* The cache key for the resource
+	*/
 	record: StableExistingRecordIdentifier;
 }
+/**
+* Adds a resource to the cache.
+*/
 export interface AddResourceOperation extends Op {
 	op: "add";
+	/**
+	* The cache key for the resource
+	*/
 	record: StableExistingRecordIdentifier;
+	/**
+	* The data for the resource
+	*/
 	value: ExistingResourceObject;
 }
+/**
+* Upserts (merges) new state for a resource
+*/
 export interface UpdateResourceOperation extends Op {
 	op: "update";
 	record: StableExistingRecordIdentifier;
 	value: ExistingResourceObject;
 }
+/**
+* Replaces the state of a field with a new state
+*/
 export interface UpdateResourceFieldOperation extends Op {
 	op: "update";
 	record: StableExistingRecordIdentifier;
 	field: string;
 	value: Value;
 }
+/**
+* Replaces the state of a relationship with a new state
+*/
 export interface UpdateResourceRelationshipOperation extends Op {
 	op: "update";
 	record: StableExistingRecordIdentifier;
 	field: string;
 	value: Relationship<StableExistingRecordIdentifier>;
 }
+/**
+* Adds a resource to a request document, optionally
+* at a specific index. This can be used to update the
+* result of a request.
+*/
 export interface AddToDocumentOperation extends Op {
 	op: "add";
 	record: StableDocumentIdentifier;
@@ -57,6 +109,9 @@ export interface AddToDocumentOperation extends Op {
 	value: StableExistingRecordIdentifier | StableExistingRecordIdentifier[];
 	index?: number;
 }
+/**
+* Adds the specified ResourceKeys to a relationship
+*/
 export interface AddToResourceRelationshipOperation extends Op {
 	op: "add";
 	record: StableExistingRecordIdentifier;
@@ -64,6 +119,9 @@ export interface AddToResourceRelationshipOperation extends Op {
 	value: StableExistingRecordIdentifier | StableExistingRecordIdentifier[];
 	index?: number;
 }
+/**
+* Removes the specified ResourceKeys from a relationship
+*/
 export interface RemoveFromResourceRelationshipOperation extends Op {
 	op: "remove";
 	record: StableExistingRecordIdentifier;
@@ -71,6 +129,11 @@ export interface RemoveFromResourceRelationshipOperation extends Op {
 	value: StableExistingRecordIdentifier | StableExistingRecordIdentifier[];
 	index?: number;
 }
+/**
+* Removes a resource from a request document, optionally
+* at a specific index. This can be used to update the
+* result of a request.
+*/
 export interface RemoveFromDocumentOperation extends Op {
 	op: "remove";
 	record: StableDocumentIdentifier;
@@ -78,8 +141,28 @@ export interface RemoveFromDocumentOperation extends Op {
 	value: StableExistingRecordIdentifier | StableExistingRecordIdentifier[];
 	index?: number;
 }
-// An Operation is an action that updates
-// the remote state of the Cache in some
-// manner. Additional Operations will be
-// added in the future.
+/**
+* {@link Cache} Operations perform updates to the
+* Cache's "remote" (or clean) state to reflect external
+* changes.
+*
+* Usually operations represent the result of a {@link WebSocket} or
+* {@link EventSource | ServerEvent} message, though they can also be used to carefully
+* patch the state of the cache with information known by the
+* application or developer.
+*
+* Operations are applied via {@link Cache.patch}.
+*
+* See also:
+* - {@link MergeOperation}
+* - {@link RemoveResourceOperation}
+* - {@link RemoveDocumentOperation}
+* - {@link AddResourceOperation}
+* - {@link UpdateResourceOperation}
+* - {@link UpdateResourceFieldOperation}
+* - {@link AddToResourceRelationshipOperation}
+* - {@link RemoveFromResourceRelationshipOperation}
+* - {@link AddToDocumentOperation}
+* - {@link RemoveFromDocumentOperation}
+*/
 export type Operation = MergeOperation | RemoveResourceOperation | RemoveDocumentOperation | AddResourceOperation | UpdateResourceOperation | UpdateResourceFieldOperation | AddToResourceRelationshipOperation | RemoveFromResourceRelationshipOperation | AddToDocumentOperation | RemoveFromDocumentOperation;

package/declarations/types/request.d.ts

@@ -163,6 +163,11 @@ export interface ConstrainedRequestOptions {
 export interface FindRecordOptions extends ConstrainedRequestOptions {
 	include?: string | string[];
 }
+/**
+* When a handler chain resolves, it returns an object
+* containing the original request, the response set by the handler
+* chain (if any), and the processed content.
+*/
 export interface StructuredDataDocument<T> {
 	[STRUCTURED]?: true;
 	/**
@@ -172,6 +177,14 @@ export interface StructuredDataDocument<T> {
 	response: Response | ResponseInfo | null;
 	content: T;
 }
+/**
+* When a handler chain rejects, it throws an Error that maintains the
+* `{ request, response, content }` shape but is also an Error instance
+* itself.
+*
+* If using the error originates from the {@link Fetch | Fetch Handler}
+* the error will be a {@link FetchError}
+*/
 export interface StructuredErrorDocument<T = unknown> extends Error {
 	[STRUCTURED]?: true;
 	request: ImmutableRequestInfo;
@@ -179,6 +192,14 @@ export interface StructuredErrorDocument<T = unknown> extends Error {
 	error: string | object;
 	content?: T;
 }
+/**
+* A union of the resolve/reject data types for a request.
+*
+* See the docs for:
+*
+* - {@link StructuredDataDocument} (resolved/successful requests)
+* - {@link StructuredErrorDocument} (rejected/failed requests)
+*/
 export type StructuredDocument<T> = StructuredDataDocument<T> | StructuredErrorDocument<T>;
 /**
 * JavaScript's native Request class.

package/declarations/types/schema/fields.d.ts

@@ -473,7 +473,7 @@ export interface ObjectField {
 		* Configures which extensions this object should use.
 		*
 		* Extensions are registered with the store's schema service
-		* via {@link SchemaService.registerDangerousObjectExtension}
+		* via {@link SchemaService.CAUTION_MEGA_DANGER_ZONE_registerExtension}
 		*
 		* Extensions should only be used for temporary enhancements
 		* to objects to support migrating away from deprecated patterns

package/dist/{context-COmAnXUQ.js → context-kQXhkeBj.js}

@@ -306,6 +306,19 @@ function ensureDoc(owner, content, isError) {
     content: 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) {
   return new DOMException(reason || 'The user aborted a request.', 'AbortError');
 }

package/dist/graph/-private.js

@@ -3122,11 +3122,11 @@ class Graph {
   }
 }
 function flushPending(graph, ops) {
-  ops.forEach(type => {
-    type.forEach(opList => {
+  for (const type of ops.values()) {
+    for (const opList of type.values()) {
       flushPendingList(graph, opList);
-    });
-  });
+    }
+  }
 }
 function flushPendingList(graph, opList) {
   for (let i = 0; i < opList.length; i++) {

package/dist/index.js

@@ -1,11 +1,12 @@
 import { setLogging, getRuntimeConfig } from './types/runtime.js';
-import { a as cloneResponseProperties, I as IS_CACHE_HANDLER, b as assertValidRequest, e as executeNextHandler, d as getRequestResult, u as upgradePromise, s as setPromiseResult, f as clearRequestResult } from "./context-COmAnXUQ.js";
+import { a as cloneResponseProperties, I as IS_CACHE_HANDLER, b as assertValidRequest, e as executeNextHandler, d as getRequestResult, u as upgradePromise, s as setPromiseResult, f as clearRequestResult } from "./context-kQXhkeBj.js";
 import { macroCondition, getGlobalConfig } from '@embroider/macros';
 import { w as waitFor } from "./configure-B48bFHOl.js";
 import { peekUniversalTransient, setUniversalTransient } from './types/-private.js';
-export { C as CacheHandler, S as Store, r as recordIdentifierFor, O as setIdentifierForgetMethod, L as setIdentifierGenerationMethod, P as setIdentifierResetMethod, N as setIdentifierUpdateMethod, Q as setKeyInfoForResource, s as storeFor } from "./request-state-BWYju5O9.js";
+export { C as CacheHandler, S as Store, r as recordIdentifierFor, K as setIdentifierForgetMethod, I as setIdentifierGenerationMethod, L as setIdentifierResetMethod, J as setIdentifierUpdateMethod, M as setKeyInfoForResource, s as storeFor } from "./request-state-CCrTjb0Z.js";
 import '@ember/debug';
 import './utils/string.js';
+import "./symbols-C5p2hcy9.js";
 
 // Lazily close over fetch to avoid breaking Mirage
 const _fetch = typeof fetch !== 'undefined' ? (...args) => fetch(...args) : typeof FastBoot !== 'undefined' ? (...args) => FastBoot.require('node-fetch')(...args) : () => {
@@ -60,6 +61,9 @@ const Fetch = {
       } else {
         e.statusText = 'Unknown Network Error';
         e.status = 0;
+        if (!(e instanceof DOMException)) {
+          e.code = 0;
+        }
         e.isRequestError = true;
       }
       throw e;

package/dist/reactive/-private.js

@@ -1 +1 @@
-export { C as Context } from "../symbols-BoONANuz.js";
+export { C as Context } from "../symbols-C5p2hcy9.js";

package/dist/reactive.js

@@ -1,7 +1,7 @@
 import { isResourceSchema } from './types/schema/fields.js';
-import { H as ReactiveResource, J as isNonIdentityCacheableField, K as getFieldCacheKeyStrict, r as recordIdentifierFor, B as withSignalStore } from "./request-state-BWYju5O9.js";
-import { D as Destroy, C as Context } from "./symbols-BoONANuz.js";
-export { a as Checkout } from "./symbols-BoONANuz.js";
+import { F as ReactiveResource, G as isNonIdentityCacheableField, H as getFieldCacheKeyStrict, r as recordIdentifierFor, z as withSignalStore } from "./request-state-CCrTjb0Z.js";
+import { D as Destroy, C as Context } from "./symbols-C5p2hcy9.js";
+export { a as Checkout } from "./symbols-C5p2hcy9.js";
 import { macroCondition, getGlobalConfig } from '@embroider/macros';
 import { warn, deprecate } from '@ember/debug';
 import './index.js';