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

package/dist/unpkg/prod-deprecated/declarations/model/-private/notify-changes.d.ts

@@ -0,0 +1,4 @@
+import type { NotificationType, Store } from "@warp-drive/core";
+import type { ResourceKey } from "@warp-drive/core/types/identifier";
+import type { Model } from "./model.js";
+export default function notifyChanges(identifier: ResourceKey, value: NotificationType, key: string | undefined, record: Model, store: Store): void;

package/dist/unpkg/prod-deprecated/declarations/model/-private/promise-belongs-to.d.ts

@@ -0,0 +1,40 @@
+import type PromiseProxyMixin from "@ember/object/promise-proxy-mixin";
+import type ObjectProxy from "@ember/object/proxy";
+import type { Store } from "@warp-drive/core";
+import type { OpaqueRecordInstance, TypeFromInstanceOrString } from "@warp-drive/core/types/record";
+import type { LegacySupport } from "./legacy-relationships-support.js";
+export interface BelongsToProxyMeta<T = unknown> {
+	key: string;
+	store: Store;
+	legacySupport: LegacySupport;
+	modelName: TypeFromInstanceOrString<T>;
+}
+export interface BelongsToProxyCreateArgs<T = unknown> {
+	promise: Promise<T | null>;
+	content?: T | null;
+	_belongsToState: BelongsToProxyMeta<T>;
+}
+export declare const LegacyPromiseProxy: unique symbol;
+interface PromiseObjectType<T> extends PromiseProxyMixin<T | null>, ObjectProxy<T> {
+	new <PT>(...args: unknown[]): PromiseObjectType<PT>;
+}
+declare class PromiseObjectType<T> {}
+declare const Extended: PromiseObjectType<OpaqueRecordInstance>;
+interface PromiseBelongsTo<T> {
+	[LegacyPromiseProxy]: true;
+}
+/**
+A PromiseBelongsTo is a PromiseObject that also proxies certain method calls
+to the underlying belongsTo model.
+Right now we proxy:
+* `reload()`
+@class PromiseBelongsTo
+@private
+*/
+declare class PromiseBelongsTo<T = unknown> extends Extended<T> {
+	_belongsToState: BelongsToProxyMeta<T>;
+	get id(): string | null;
+	get meta(): void;
+	reload(options: Record<string, unknown>): Promise<this>;
+}
+export { PromiseBelongsTo };

package/dist/unpkg/prod-deprecated/declarations/model/-private/promise-many-array.d.ts

@@ -0,0 +1,124 @@
+import type { RelatedCollection as ManyArray } from "@warp-drive/core/store/-private";
+import type { BaseFinderOptions } from "@warp-drive/core/types";
+import type { Links } from "@warp-drive/core/types/spec/json-api-raw";
+import { LegacyPromiseProxy } from "./promise-belongs-to.js";
+export interface HasManyProxyCreateArgs<T = unknown> {
+	promise: Promise<ManyArray<T>>;
+	content?: ManyArray<T>;
+}
+export interface PromiseManyArray<T> {
+	[LegacyPromiseProxy]: true;
+}
+/**
+This class is returned as the result of accessing an async hasMany relationship
+on an instance of a Model extending from `@ember-data/model`.
+
+A PromiseManyArray is an iterable proxy that allows templates to consume related
+ManyArrays and update once their contents are no longer pending.
+
+In your JS code you should resolve the promise first.
+
+```js
+const comments = await post.comments;
+```
+
+@class PromiseManyArray
+@public
+*/
+export declare class PromiseManyArray<T = unknown> {
+	promise: Promise<ManyArray<T>> | null;
+	isDestroyed: boolean;
+	content: ManyArray<T> | null;
+	constructor(promise: Promise<ManyArray<T>>, content?: ManyArray<T>);
+	/**
+	* Retrieve the length of the content
+	* @property length
+	* @public
+	*/
+	get length(): number;
+	get "[]"(): 0 | ManyArray<T> | undefined;
+	/**
+	* Iterate the proxied content. Called by the glimmer iterator in #each
+	* We do not guarantee that forEach will always be available. This
+	* may eventually be made to use Symbol.Iterator once glimmer supports it.
+	*
+	* @param cb
+	* @return
+	* @private
+	*/
+	forEach(cb: (item: T, index: number, array: T[]) => void): void;
+	/**
+	* Reload the relationship
+	* @public
+	* @param options
+	* @return
+	*/
+	reload(options: Omit<BaseFinderOptions, "">): this;
+	/**
+	* Whether the loading promise is still pending
+	*
+	* @property isPending
+	* @type {Boolean}
+	* @public
+	*/
+	isPending: boolean;
+	/**
+	* Whether the loading promise rejected
+	*
+	* @property isRejected
+	* @type {Boolean}
+	* @public
+	*/
+	isRejected: boolean;
+	/**
+	* Whether the loading promise succeeded
+	*
+	* @property isFulfilled
+	* @type {Boolean}
+	* @public
+	*/
+	isFulfilled: boolean;
+	/**
+	* Whether the loading promise completed (resolved or rejected)
+	*
+	* @property isSettled
+	* @type {Boolean}
+	* @public
+	*/
+	isSettled: boolean;
+	/**
+	* chain this promise
+	*
+	* @public
+	*/
+	then(success: Parameters<Promise<ManyArray<T>>["then"]>[0], rejected?: Parameters<Promise<ManyArray<T>>["then"]>[1]): Promise<unknown>;
+	/**
+	* catch errors thrown by this promise
+	* @public
+	* @param callback
+	* @return {Promise}
+	*/
+	catch(cb: Parameters<Promise<ManyArray<T>>["catch"]>[0]): Promise<unknown>;
+	/**
+	* run cleanup after this promise completes
+	*
+	* @public
+	* @param callback
+	* @return {Promise}
+	*/
+	finally(cb: Parameters<Promise<ManyArray<T>>["finally"]>[0]): Promise<unknown>;
+	destroy(): void;
+	/**
+	* Retrieve the links for this relationship
+	* @property links
+	* @public
+	*/
+	get links(): Links | null | undefined;
+	/**
+	* Retrieve the meta for this relationship
+	* @property meta
+	* @public
+	*/
+	get meta(): Record<string, unknown> | null | undefined;
+	static create<T>({ promise, content }: HasManyProxyCreateArgs<T>): PromiseManyArray<T>;
+}

package/dist/unpkg/prod-deprecated/declarations/model/-private/record-state.d.ts

@@ -0,0 +1,58 @@
+import type { MinimalLegacyRecord } from "./model-methods.js";
+/**
+Historically WarpDrive managed a state machine
+for each record, the localState for which
+was reflected onto Model.
+
+This implements the flags and stateName for backwards compat
+with the state tree that used to be possible (listed below).
+
+stateName and dirtyType are candidates for deprecation.
+
+root
+empty
+deleted    // hidden from stateName
+preloaded  // hidden from stateName
+
+loading
+empty     // hidden from stateName
+preloaded // hidden from stateName
+
+loaded
+saved
+updated
+uncommitted
+invalid
+inFlight
+created
+uncommitted
+invalid
+inFlight
+
+deleted
+saved
+new      // hidden from stateName
+uncommitted
+invalid
+inFlight
+
+@hideconstructor
+@private
+*/
+export default class RecordState {
+	constructor(record: MinimalLegacyRecord);
+	isSaving: boolean;
+	get isLoading(): boolean;
+	get isLoaded(): boolean;
+	get isSaved(): boolean;
+	get isEmpty(): boolean;
+	get isNew(): boolean;
+	get isDeleted(): boolean;
+	get isValid(): boolean;
+	get isDirty(): boolean;
+	get isError(): boolean;
+	get adapterError(): unknown;
+	get isPreloaded(): boolean;
+	get stateName(): "root.loading" | "root.empty" | "root.deleted.inFlight" | "root.deleted.saved" | "root.deleted.invalid" | "root.deleted.uncommitted" | "root.loaded.created.inFlight" | "root.loaded.created.invalid" | "root.loaded.created.uncommitted" | "root.loaded.updated.inFlight" | "root.loaded.updated.invalid" | "root.loaded.updated.uncommitted" | "root.loaded.saved";
+	get dirtyType(): "" | "deleted" | "created" | "updated";
+}