@warp-drive/core 5.8.0-alpha.30 → 5.8.0-alpha.34

package/dist/unpkg/prod-deprecated/declarations/store/-private/record-arrays/legacy-many-array.d.ts

@@ -0,0 +1,133 @@
+import type { BaseFinderOptions, ResourceKey } from "../../../types.js";
+import type { TypedRecordInstance, TypeFromInstance } from "../../../types/record.js";
+import type { LegacyHasManyField, LinksModeHasManyField } from "../../../types/schema/fields.js";
+import type { Links, Meta, PaginationLinks } from "../../../types/spec/json-api-raw.js";
+import type { CreateRecordProperties } from "../store-service.js";
+import type { LegacyLiveArrayCreateOptions } from "./legacy-live-array.js";
+import { type ReactiveResourceArray } from "./resource-array.js";
+/**
+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.
+
+This class is not intended to be directly instantiated by consuming applications.
+
+### Inverses
+
+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';
+
+export default class PostModel extends Model {
+@hasMany('comment') comments;
+}
+```
+
+```js [app/models/comment.js]
+import { Model, belongsTo } from '@warp-drive/legacy/model';
+
+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.
+
+We call the record to which a relationship belongs-to the
+relationship's _owner_.
+
+@public
+*/
+export interface LegacyManyArray<T = unknown> extends ReactiveResourceArray<T> {
+	meta: Meta | null;
+	links: Links | PaginationLinks | null;
+	/** @private */
+	key: string;
+	/** @private */
+	modelName: T extends TypedRecordInstance ? TypeFromInstance<T> : string;
+	/**
+	The loading state of this array
+	@public
+	*/
+	isLoaded: boolean;
+	/**
+	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<LegacyManyArray<T>>;
+	/**
+	Create a child record and associated it to the collection
+	
+	@public
+	*/
+	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
+	
+	```js
+	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
+	*/
+	save: () => Promise<LegacyManyArray<T>>;
+	/** @private */
+	destroy: () => void;
+}
+/**
+* The options for {@link createLegacyManyArray}
+*
+* @private
+*/
+export interface LegacyManyArrayCreateOptions extends LegacyLiveArrayCreateOptions {
+	isLoaded: boolean;
+	editable: boolean;
+	isAsync: boolean;
+	isPolymorphic: boolean;
+	field: LegacyHasManyField | LinksModeHasManyField;
+	identifier: ResourceKey;
+	links: Links | PaginationLinks | null;
+	meta: Meta | null;
+}
+/**
+* Creates a {@link LegacyManyArray}
+*
+* @private
+*/
+export declare function createLegacyManyArray<T>(options: LegacyManyArrayCreateOptions): LegacyManyArray<T>;

package/dist/unpkg/prod-deprecated/declarations/store/-private/record-arrays/legacy-query.d.ts

@@ -0,0 +1,81 @@
+import type { ImmutableRequestInfo } from "../../../types/request.js";
+import type { Links, Meta, PaginationLinks } from "../../../types/spec/json-api-raw.js";
+import type { LegacyLiveArray } 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;
+}

package/dist/unpkg/prod-deprecated/declarations/store/-private/record-arrays/native-proxy-type-fix.d.ts

@@ -0,0 +1,3 @@
+interface ProxyConstructor {}
+export declare const NativeProxy: ProxyConstructor;
+export {};

package/dist/unpkg/prod-deprecated/declarations/store/-private/record-arrays/resource-array.d.ts

@@ -0,0 +1,67 @@
+import type { ExtensionDef } from "../../../reactive.js";
+import { Context } from "../../../reactive/-private.js";
+import type { RequestKey, ResourceKey } 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 {
+	store: Store;
+	manager: MinimumManager;
+	editable: boolean;
+	source: ResourceKey[];
+	data: ObjectValue | null;
+	features: Record<string | symbol, unknown> | null;
+	extensions: Map<string | symbol, ExtensionDef> | null;
+	options: Record<string, unknown> | null;
+	destroy: null | ((this: ReactiveResourceArray, clear: boolean) => void);
+	mutate: null | ((target: ResourceKey[], receiver: typeof NativeProxy<ResourceKey[], unknown[]>, prop: string, args: unknown[], _SIGNAL: WarpDriveSignal) => unknown);
+}
+interface ReactiveResourceArrayContext extends ReactiveResourceArrayCreateOptions {
+	destroy: (this: ReactiveResourceArray, clear: boolean) => void;
+	mutate: (target: ResourceKey[], receiver: typeof NativeProxy<ResourceKey[], unknown[]>, prop: string, args: unknown[], _SIGNAL: WarpDriveSignal) => unknown;
+	signals: SignalStore;
+	signal: WarpDriveSignal;
+	isDestroying: boolean;
+	isDestroyed: boolean;
+	transaction: boolean;
+	boundFns: Map<KeyType, ProxiedMethod>;
+}
+export interface ReactiveResourceArray<T = unknown> extends Omit<Array<T>, "[]"> {}
+export interface PrivateReactiveResourceArray<T = unknown> extends Omit<Array<T>, "[]"> {
+	isDestroying: boolean;
+	isDestroyed: boolean;
+	destroy: (this: ReactiveResourceArray, clear: boolean) => void;
+	[IS_COLLECTION]: boolean;
+	[Context]: ReactiveResourceArrayContext;
+}
+export interface TargetArray extends Array<ResourceKey> {}
+export declare function createReactiveResourceArray<T>(options: ReactiveResourceArrayCreateOptions): ReactiveResourceArray<T>;
+export declare function destroy(this: ReactiveResourceArray, clear: boolean): void;
+export interface ReactiveRequestCollectionCreateArgs {
+	store: Store;
+	manager: MinimumManager;
+	source: ResourceKey[];
+	options: {
+		requestKey: RequestKey;
+	} | null;
+}
+export declare function createRequestCollection(config: ReactiveRequestCollectionCreateArgs): ReactiveResourceArray;
+export interface ReactiveRelatedCollectionCreateArgs {
+	store: Store;
+	manager: MinimumManager;
+	source: ResourceKey[];
+	options: {
+		resourceKey: ResourceKey;
+		path: string[];
+		field: CollectionField;
+	};
+	editable: boolean;
+	extensions: Map<string | symbol, ExtensionDef> | null;
+}
+export declare function createRelatedCollection(config: ReactiveRelatedCollectionCreateArgs): ReactiveResourceArray;
+export {};