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

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

@@ -1,143 +1,147 @@
-import type { BaseFinderOptions } from '../../../types';
-import type { LocalRelationshipOperation } from '../../../types/graph.ts';
-import type { StableDocumentIdentifier, StableRecordIdentifier } from '../../../types/identifier.ts';
-import type { TypeFromInstanceOrString } from '../../../types/record.ts';
-import type { ImmutableRequestInfo } from '../../../types/request.ts';
-import type { LegacyHasManyField, LinksModeHasManyField } from '../../../types/schema/fields.ts';
-import type { Links, PaginationLinks } from '../../../types/spec/json-api-raw.ts';
-import type { RecordArrayManager } from '../managers/record-array-manager.ts';
-import type { WarpDriveSignal } from '../new-core-tmp/reactivity/internal.ts';
-import { ARRAY_SIGNAL } from '../new-core-tmp/reactivity/internal.ts';
-import type { Store } from '../store-service.ts';
-import { NativeProxy } from './native-proxy-type-fix.ts';
+import type { BaseFinderOptions } from "../../../types.js";
+import type { LocalRelationshipOperation } from "../../../types/graph.js";
+import type { StableDocumentIdentifier, StableRecordIdentifier } from "../../../types/identifier.js";
+import type { TypeFromInstanceOrString } from "../../../types/record.js";
+import type { ImmutableRequestInfo } from "../../../types/request.js";
+import type { LegacyHasManyField, LinksModeHasManyField } from "../../../types/schema/fields.js";
+import type { Links, PaginationLinks } from "../../../types/spec/json-api-raw.js";
+import type { RecordArrayManager } from "../managers/record-array-manager.js";
+import type { WarpDriveSignal } from "../new-core-tmp/reactivity/internal.js";
+import { ARRAY_SIGNAL } from "../new-core-tmp/reactivity/internal.js";
+import type { Store } from "../store-service.js";
+import { NativeProxy } from "./native-proxy-type-fix.js";
 export declare const SOURCE: "___(unique) Symbol(#source)";
 export declare const MUTATE: "___(unique) Symbol(#update)";
 declare const IS_COLLECTION: "___(unique) Symbol(IS_COLLECTION)";
 export type IdentifierArrayCreateOptions<T = unknown> = {
-    identifiers: StableRecordIdentifier<TypeFromInstanceOrString<T>>[];
-    type?: TypeFromInstanceOrString<T>;
-    store: Store;
-    allowMutation: boolean;
-    manager: MinimumManager;
-    field?: LegacyHasManyField | LinksModeHasManyField;
-    links?: Links | PaginationLinks | null;
-    meta?: Record<string, unknown> | null;
-    identifier?: StableDocumentIdentifier | null;
+	identifiers: StableRecordIdentifier<TypeFromInstanceOrString<T>>[];
+	type?: TypeFromInstanceOrString<T>;
+	store: Store;
+	allowMutation: boolean;
+	manager: MinimumManager;
+	field?: LegacyHasManyField | LinksModeHasManyField;
+	links?: Links | PaginationLinks | null;
+	meta?: Record<string, unknown> | null;
+	identifier?: StableDocumentIdentifier | null;
+	[MUTATE]?(target: StableRecordIdentifier[], receiver: typeof NativeProxy<StableRecordIdentifier[], T[]>, prop: string, args: unknown[], _SIGNAL: WarpDriveSignal): unknown;
 };
 type PromiseTo<T> = Omit<Promise<T>, typeof Symbol.toStringTag>;
 type PromiseManyArray<T> = {
-    length: number;
-    content: IdentifierArray<T> | null;
-    promise: Promise<IdentifierArray<T>> | null;
+	length: number;
+	content: IdentifierArray<T> | null;
+	promise: Promise<IdentifierArray<T>> | null;
 } & PromiseTo<IdentifierArray<T>>;
 export type MinimumManager = {
-    _syncArray: (array: IdentifierArray) => void;
-    mutate?(mutation: LocalRelationshipOperation): void;
-    reloadHasMany?<T>(key: string, options?: BaseFinderOptions): Promise<IdentifierArray<T>> | PromiseManyArray<T>;
+	_syncArray: (array: IdentifierArray) => void;
+	mutate?(mutation: LocalRelationshipOperation): void;
+	reloadHasMany?<T>(key: string, options?: BaseFinderOptions): Promise<IdentifierArray<T>> | PromiseManyArray<T>;
 };
 /**
-  A record array is an array that contains records of a certain type (or modelName).
-  The record array materializes records as needed when they are retrieved for the first
-  time. You should not create record arrays yourself. Instead, an instance of
-  `RecordArray` or its subclasses will be returned by your application's store
-  in response to queries.
+A record array is an array that contains records of a certain type (or modelName).
+The record array materializes records as needed when they are retrieved for the first
+time. You should not create record arrays yourself. Instead, an instance of
+`RecordArray` or its subclasses will be returned by your application's store
+in response to queries.
 
-  This class should not be imported and instantiated by consuming applications.
+This class should not be imported and instantiated by consuming applications.
 
-  @class RecordArray
-  @public
+@class RecordArray
+@public
 */
-export interface IdentifierArray<T = unknown> extends Omit<Array<T>, '[]'> {
-    [MUTATE]?(target: StableRecordIdentifier[], receiver: typeof NativeProxy<StableRecordIdentifier[], T[]>, prop: string, args: unknown[], _SIGNAL: WarpDriveSignal): unknown;
+export interface IdentifierArray<T = unknown> extends Omit<Array<T>, "[]"> {
+	[IS_COLLECTION]: boolean;
+	[ARRAY_SIGNAL]: WarpDriveSignal;
+	[SOURCE]: StableRecordIdentifier[];
 }
 export declare class IdentifierArray<T = unknown> {
-    DEPRECATED_CLASS_NAME: string;
-    /**
-      The flag to signal a `RecordArray` is currently loading data.
-      Example
-      ```javascript
-      let people = store.peekAll('person');
-      people.isUpdating; // false
-      people.update();
-      people.isUpdating; // true
-      ```
-      @property isUpdating
-      @public
-      @type Boolean
-    */
-    isUpdating: boolean;
-    isLoaded: boolean;
-    isDestroying: boolean;
-    isDestroyed: boolean;
-    _updatingPromise: Promise<IdentifierArray<T>> | null;
-    readonly identifier: StableDocumentIdentifier | null;
-    [IS_COLLECTION]: boolean;
-    [ARRAY_SIGNAL]: WarpDriveSignal;
-    [SOURCE]: StableRecordIdentifier[];
-    links: Links | PaginationLinks | null;
-    meta: Record<string, unknown> | null;
-    modelName?: TypeFromInstanceOrString<T>;
-    /**
-      The store that created this record array.
-  
-      @property store
-      @private
-      @type Store
-      */
-    store: Store;
-    _manager: MinimumManager;
-    destroy(clear: boolean): void;
-    constructor(options: IdentifierArrayCreateOptions<T>);
-    /**
-      Used to get the latest version of all of the records in this array
-      from the adapter.
-  
-      Example
-  
-      ```javascript
-      let people = store.peekAll('person');
-      people.isUpdating; // false
-  
-      people.update().then(function() {
-        people.isUpdating; // false
-      });
-  
-      people.isUpdating; // true
-      ```
-  
-      @public
-    */
-    update(): Promise<IdentifierArray<T>>;
-    _update(): Promise<IdentifierArray<T>>;
-    /**
-      Saves all of the records in the `RecordArray`.
-  
-      Example
-  
-      ```javascript
-      let messages = store.peekAll('message');
-      messages.forEach(function(message) {
-        message.hasBeenSeen = true;
-      });
-      messages.save();
-      ```
-  
-      @public
-      @return {Promise<IdentifierArray>} promise
-    */
-    save(): Promise<IdentifierArray>;
+	DEPRECATED_CLASS_NAME: string;
+	/**
+	The flag to signal a `RecordArray` is currently loading data.
+	Example
+	```javascript
+	let people = store.peekAll('person');
+	people.isUpdating; // false
+	people.update();
+	people.isUpdating; // true
+	```
+	@property isUpdating
+	@public
+	@type Boolean
+	*/
+	isUpdating: boolean;
+	isLoaded: boolean;
+	isDestroying: boolean;
+	isDestroyed: boolean;
+	_updatingPromise: Promise<IdentifierArray<T>> | null;
+	readonly identifier: StableDocumentIdentifier | null;
+	links: Links | PaginationLinks | null;
+	meta: Record<string, unknown> | null;
+	modelName?: TypeFromInstanceOrString<T>;
+	/**
+	The store that created this record array.
+	
+	@property store
+	@private
+	@type Store
+	*/
+	store: Store;
+	_manager: MinimumManager;
+	destroy(clear: boolean): void;
+	constructor(options: IdentifierArrayCreateOptions<T>);
+	/**
+	Used to get the latest version of all of the records in this array
+	from the adapter.
+	
+	Example
+	
+	```javascript
+	let people = store.peekAll('person');
+	people.isUpdating; // false
+	
+	people.update().then(function() {
+	people.isUpdating; // false
+	});
+	
+	people.isUpdating; // true
+	```
+	
+	@public
+	*/
+	update(): Promise<IdentifierArray<T>>;
+	/*
+	Update this Array and return a promise which resolves once the update
+	is finished.
+	*/
+	_update(): Promise<IdentifierArray<T>>;
+	// TODO deprecate
+	/**
+	Saves all of the records in the `RecordArray`.
+	
+	Example
+	
+	```javascript
+	let messages = store.peekAll('message');
+	messages.forEach(function(message) {
+	message.hasBeenSeen = true;
+	});
+	messages.save();
+	```
+	
+	@public
+	@return {Promise<IdentifierArray>} promise
+	*/
+	save(): Promise<IdentifierArray>;
 }
 export type CollectionCreateOptions = IdentifierArrayCreateOptions & {
-    manager: RecordArrayManager;
-    query: ImmutableRequestInfo | Record<string, unknown> | null;
-    isLoaded: boolean;
+	manager: RecordArrayManager;
+	query: ImmutableRequestInfo | Record<string, unknown> | null;
+	isLoaded: boolean;
 };
 export declare class Collection<T = unknown> extends IdentifierArray<T> {
-    query: ImmutableRequestInfo | Record<string, unknown> | null;
-    _manager: RecordArrayManager;
-    constructor(options: CollectionCreateOptions);
-    _update(): Promise<Collection<T>>;
-    destroy(clear: boolean): void;
+	query: ImmutableRequestInfo | Record<string, unknown> | null;
+	_manager: RecordArrayManager;
+	constructor(options: CollectionCreateOptions);
+	_update(): Promise<Collection<T>>;
+	destroy(clear: boolean): void;
 }
 export {};
-//# sourceMappingURL=identifier-array.d.ts.map

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

@@ -1,201 +1,197 @@
-import type { BaseFinderOptions, ModelSchema, StableRecordIdentifier } from '../../../types.ts';
-import type { Cache } from '../../../types/cache.ts';
-import type { TypedRecordInstance, TypeFromInstance, TypeFromInstanceOrString } from '../../../types/record.ts';
-import type { LegacyHasManyField, LinksModeHasManyField } from '../../../types/schema/fields.ts';
-import type { Links, PaginationLinks } from '../../../types/spec/json-api-raw.ts';
-import { type WarpDriveSignal } from '../new-core-tmp/reactivity/internal.ts';
-import type { CreateRecordProperties, Store } from '../store-service.ts';
-import type { MinimumManager } from './identifier-array.ts';
-import { IdentifierArray, MUTATE } from './identifier-array.ts';
-import type { NativeProxy } from './native-proxy-type-fix.ts';
+import type { BaseFinderOptions, ModelSchema, StableRecordIdentifier } from "../../../types.js";
+import type { Cache } from "../../../types/cache.js";
+import type { TypedRecordInstance, TypeFromInstance, TypeFromInstanceOrString } from "../../../types/record.js";
+import type { LegacyHasManyField, LinksModeHasManyField } from "../../../types/schema/fields.js";
+import type { Links, PaginationLinks } from "../../../types/spec/json-api-raw.js";
+import type { CreateRecordProperties, Store } from "../store-service.js";
+import type { MinimumManager } from "./identifier-array.js";
+import { IdentifierArray } from "./identifier-array.js";
 export interface ManyArrayCreateArgs<T> {
-    identifiers: StableRecordIdentifier<TypeFromInstanceOrString<T>>[];
-    type: TypeFromInstanceOrString<T>;
-    store: Store;
-    allowMutation: boolean;
-    manager: MinimumManager;
-    field?: LegacyHasManyField | LinksModeHasManyField;
-    identifier: StableRecordIdentifier;
-    cache: Cache;
-    meta: Record<string, unknown> | null;
-    links: Links | PaginationLinks | null;
-    key: string;
-    isPolymorphic: boolean;
-    isAsync: boolean;
-    _inverseIsAsync: boolean;
-    isLoaded: boolean;
+	identifiers: StableRecordIdentifier<TypeFromInstanceOrString<T>>[];
+	type: TypeFromInstanceOrString<T>;
+	store: Store;
+	allowMutation: boolean;
+	manager: MinimumManager;
+	field?: LegacyHasManyField | LinksModeHasManyField;
+	identifier: StableRecordIdentifier;
+	cache: Cache;
+	meta: Record<string, unknown> | null;
+	links: Links | PaginationLinks | null;
+	key: string;
+	isPolymorphic: boolean;
+	isAsync: boolean;
+	_inverseIsAsync: boolean;
+	isLoaded: boolean;
 }
 /**
-  A `ManyArray` is a `MutableArray` that represents the contents of a has-many
-  relationship.
+A `ManyArray` is a `MutableArray` that represents the contents of a has-many
+relationship.
 
-  The `ManyArray` is instantiated lazily the first time the relationship is
-  requested.
+The `ManyArray` is instantiated lazily the first time the relationship is
+requested.
 
-  This class is not intended to be directly instantiated by consuming applications.
+This class is not intended to be directly instantiated by consuming applications.
 
-  ### Inverses
+### Inverses
 
-  Often, the relationships in Ember Data applications will have
-  an inverse. For example, imagine the following models are
-  defined:
+Often, the relationships in Ember Data applications will have
+an inverse. For example, imagine the following models are
+defined:
 
-  ```js [app/models/post.js]
-  import Model, { hasMany } from '@ember-data/model';
+```js [app/models/post.js]
+import Model, { hasMany } from '@ember-data/model';
 
-  export default class PostModel extends Model {
-    @hasMany('comment') comments;
-  }
-  ```
+export default class PostModel extends Model {
+@hasMany('comment') comments;
+}
+```
 
-  ```js [app/models/comment.js]
-  import { Model, belongsTo } from '@warp-drive/legacy/model';
+```js [app/models/comment.js]
+import { Model, belongsTo } from '@warp-drive/legacy/model';
 
-  export default class CommentModel extends Model {
-    @belongsTo('post') post;
-  }
-  ```
+export default class CommentModel extends Model {
+@belongsTo('post') post;
+}
+```
 
-  If you created a new instance of `Post` and added
-  a `Comment` record to its `comments` has-many
-  relationship, you would expect the comment's `post`
-  property to be set to the post that contained
-  the has-many.
+If you created a new instance of `Post` and added
+a `Comment` record to its `comments` has-many
+relationship, you would expect the comment's `post`
+property to be set to the post that contained
+the has-many.
 
-  We call the record to which a relationship belongs-to the
-  relationship's _owner_.
+We call the record to which a relationship belongs-to the
+relationship's _owner_.
 
-  @class ManyArray
-  @public
+@class ManyArray
+@public
 */
 export declare class RelatedCollection<T = unknown> extends IdentifierArray<T> {
-    isAsync: boolean;
-    /**
-      The loading state of this array
-  
-      @property isLoaded
-      @type {Boolean}
-      @public
-      */
-    isLoaded: boolean;
-    /**
-      `true` if the relationship is polymorphic, `false` otherwise.
-  
-      @property isPolymorphic
-      @type {Boolean}
-      @private
-      */
-    isPolymorphic: boolean;
-    _inverseIsAsync: boolean;
-    /**
-      Metadata associated with the request for async hasMany relationships.
-  
-      Example
-  
-      Given that the server returns the following JSON payload when fetching a
-      hasMany relationship:
-  
-      ```js
-      {
-        "comments": [{
-          "id": 1,
-          "comment": "This is the first comment",
-        }, {
-      // ...
-        }],
-  
-        "meta": {
-          "page": 1,
-          "total": 5
-        }
-      }
-      ```
-  
-      You can then access the meta data via the `meta` property:
-  
-      ```js
-      let comments = await post.comments;
-      let meta = comments.meta;
-  
-      // meta.page => 1
-      // meta.total => 5
-      ```
-  
-      @property meta
-      @type {Object | null}
-      @public
-      */
-    meta: Record<string, unknown> | null;
-    /**
-       * Retrieve the links for this relationship
-       *
-       @property links
-       @type {Object | null}
-       @public
-       */
-    links: Links | PaginationLinks | null;
-    identifier: StableRecordIdentifier;
-    cache: Cache;
-    _manager: MinimumManager;
-    store: Store;
-    key: string;
-    type: ModelSchema;
-    modelName: T extends TypedRecordInstance ? TypeFromInstance<T> : string;
-    constructor(options: ManyArrayCreateArgs<T>);
-    [MUTATE](target: StableRecordIdentifier[], receiver: typeof NativeProxy<StableRecordIdentifier[], T[]>, prop: string, args: unknown[], _SIGNAL: WarpDriveSignal): unknown;
-    notify(): void;
-    /**
-      Reloads all of the records in the manyArray. If the manyArray
-      holds a relationship that was originally fetched using a links url
-      WarpDrive will revisit the original links url to repopulate the
-      relationship.
-  
-      If the ManyArray holds the result of a `store.query()` reload will
-      re-run the original query.
-  
-      Example
-  
-      ```javascript
-      let user = store.peekRecord('user', '1')
-      await login(user);
-  
-      let permissions = await user.permissions;
-      await permissions.reload();
-      ```
-  
-      @public
-    */
-    reload(options?: BaseFinderOptions): Promise<this>;
-    /**
-      Create a child record within the owner
-  
-      @public
-      @param {Object} hash
-      @return {Model} record
-    */
-    createRecord(hash: CreateRecordProperties<T>): T;
-    /**
-      Saves all of the records in the `ManyArray`.
-  
-      Note: this API can only be used in legacy mode with a configured Adapter.
-  
-      Example
-  
-      ```javascript
-      const { content: { data: inbox } } = await store.request(findRecord({ type: 'inbox', id: '1' }));
-  
-      let messages = await inbox.messages;
-      messages.forEach((message) => {
-        message.isRead = true;
-      });
-      messages.save();
-      ```
-  
-      @public
-      @return {PromiseArray} promise
-    */
-    save: () => Promise<IdentifierArray<T>>;
-    /** @internal */
-    destroy(): void;
+	isAsync: boolean;
+	/**
+	The loading state of this array
+	
+	@property isLoaded
+	@type {Boolean}
+	@public
+	*/
+	isLoaded: boolean;
+	/**
+	`true` if the relationship is polymorphic, `false` otherwise.
+	
+	@property isPolymorphic
+	@type {Boolean}
+	@private
+	*/
+	isPolymorphic: boolean;
+	_inverseIsAsync: boolean;
+	/**
+	Metadata associated with the request for async hasMany relationships.
+	
+	Example
+	
+	Given that the server returns the following JSON payload when fetching a
+	hasMany relationship:
+	
+	```js
+	{
+	"comments": [{
+	"id": 1,
+	"comment": "This is the first comment",
+	}, {
+	// ...
+	}],
+	
+	"meta": {
+	"page": 1,
+	"total": 5
+	}
+	}
+	```
+	
+	You can then access the meta data via the `meta` property:
+	
+	```js
+	let comments = await post.comments;
+	let meta = comments.meta;
+	
+	// meta.page => 1
+	// meta.total => 5
+	```
+	
+	@property meta
+	@type {Object | null}
+	@public
+	*/
+	meta: Record<string, unknown> | null;
+	/**
+	* Retrieve the links for this relationship
+	*
+	@property links
+	@type {Object | null}
+	@public
+	*/
+	links: Links | PaginationLinks | null;
+	identifier: StableRecordIdentifier;
+	cache: Cache;
+	_manager: MinimumManager;
+	store: Store;
+	key: string;
+	type: ModelSchema;
+	modelName: T extends TypedRecordInstance ? TypeFromInstance<T> : string;
+	constructor(options: ManyArrayCreateArgs<T>);
+	notify(): void;
+	/**
+	Reloads all of the records in the manyArray. If the manyArray
+	holds a relationship that was originally fetched using a links url
+	WarpDrive will revisit the original links url to repopulate the
+	relationship.
+	
+	If the ManyArray holds the result of a `store.query()` reload will
+	re-run the original query.
+	
+	Example
+	
+	```javascript
+	let user = store.peekRecord('user', '1')
+	await login(user);
+	
+	let permissions = await user.permissions;
+	await permissions.reload();
+	```
+	
+	@public
+	*/
+	reload(options?: BaseFinderOptions): Promise<this>;
+	/**
+	Create a child record within the owner
+	
+	@public
+	@param {Object} hash
+	@return {Model} record
+	*/
+	createRecord(hash: CreateRecordProperties<T>): T;
+	/**
+	Saves all of the records in the `ManyArray`.
+	
+	Note: this API can only be used in legacy mode with a configured Adapter.
+	
+	Example
+	
+	```javascript
+	const { content: { data: inbox } } = await store.request(findRecord({ type: 'inbox', id: '1' }));
+	
+	let messages = await inbox.messages;
+	messages.forEach((message) => {
+	message.isRead = true;
+	});
+	messages.save();
+	```
+	
+	@public
+	@return {PromiseArray} promise
+	*/
+	save: () => Promise<IdentifierArray<T>>;
+	/** @internal */
+	destroy(): void;
 }
-//# sourceMappingURL=many-array.d.ts.map