@warp-drive/legacy 5.6.0-alpha.15 → 5.6.0-alpha.17

package/declarations/model/-private/notify-changes.d.ts

@@ -1,5 +1,4 @@
-import type { NotificationType, Store } from '@warp-drive/core';
-import type { StableRecordIdentifier } from '@warp-drive/core/types/identifier';
-import type { Model } from './model.ts';
+import type { NotificationType, Store } from "@warp-drive/core";
+import type { StableRecordIdentifier } from "@warp-drive/core/types/identifier";
+import type { Model } from "./model.js";
 export default function notifyChanges(identifier: StableRecordIdentifier, value: NotificationType, key: string | undefined, record: Model, store: Store): void;
-//# sourceMappingURL=notify-changes.d.ts.map

package/declarations/model/-private/promise-belongs-to.d.ts

@@ -1,40 +1,46 @@
-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.ts';
+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>;
+	key: string;
+	store: Store;
+	legacySupport: LegacySupport;
+	modelName: TypeFromInstanceOrString<T>;
 }
 export interface BelongsToProxyCreateArgs<T = unknown> {
-    promise: Promise<T | null>;
-    content?: T | null;
-    _belongsToState: BelongsToProxyMeta<T>;
+	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> {
+	// eslint-disable-next-line @typescript-eslint/no-misused-new
+	new <PT>(...args: unknown[]): PromiseObjectType<PT>;
 }
+// eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-extraneous-class
+declare class PromiseObjectType<T> {}
 declare const Extended: PromiseObjectType<OpaqueRecordInstance>;
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+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
+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>;
-    [LegacyPromiseProxy]: true;
+	_belongsToState: BelongsToProxyMeta<T>;
+	get id(): string | null;
+	// we don't proxy meta because we would need to proxy it to the relationship state container
+	//  however, meta on relationships does not trigger change notifications.
+	//  if you need relationship meta, you should do `record.belongsTo(relationshipName).meta()`
+	get meta(): void;
+	reload(options: Record<string, unknown>): Promise<this>;
 }
 export { PromiseBelongsTo };
-//# sourceMappingURL=promise-belongs-to.d.ts.map

package/declarations/model/-private/promise-many-array.d.ts

@@ -1,126 +1,135 @@
-import type { RelatedCollection as ManyArray } from '@warp-drive/core/store/-private';
-import type { BaseFinderOptions } from '@warp-drive/core/types';
-import { LegacyPromiseProxy } from './promise-belongs-to.ts';
+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>;
+	promise: Promise<ManyArray<T>>;
+	content?: ManyArray<T>;
+}
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+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`.
+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.
+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.
+In your JS code you should resolve the promise first.
 
-  ```js
-  const comments = await post.comments;
-  ```
+```js
+const comments = await post.comments;
+```
 
-  @class PromiseManyArray
-  @public
+@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
-     * @param success
-     * @param fail
-     * @return {Promise}
-     */
-    then(s: Parameters<Promise<ManyArray<T>>['then']>[0], f?: 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<ManyArray<T>>;
-    destroy(): void;
-    /**
-     * Retrieve the links for this relationship
-     * @property links
-     * @public
-     */
-    get links(): import("@warp-drive/core/types/spec/json-api-raw.js").Links | null | undefined;
-    /**
-     * Retrieve the meta for this relationship
-     * @property meta
-     * @public
-     */
-    get meta(): Record<string, unknown> | null | undefined;
-    _update(promise: Promise<ManyArray<T>>, content?: ManyArray<T>): void;
-    static create<T>({ promise, content }: HasManyProxyCreateArgs<T>): PromiseManyArray<T>;
-    [LegacyPromiseProxy]: true;
+	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;
+	// this will error if someone tries to call
+	// A(identifierArray) since it is not configurable
+	// which is preferrable to the `meta` override we used
+	// before which required importing all of Ember
+	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;
+	//----  Properties/Methods from the PromiseProxyMixin that we will keep as our API
+	/**
+	* 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>;
+	//---- Methods on EmberObject that we should keep
+	destroy(): void;
+	//---- Methods/Properties on ManyArray that we own and proxy to
+	/**
+	* 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;
+	//---- Our own stuff
+	/** @internal */
+	_update(promise: Promise<ManyArray<T>>, content?: ManyArray<T>): void;
+	static create<T>({ promise, content }: HasManyProxyCreateArgs<T>): PromiseManyArray<T>;
 }
-//# sourceMappingURL=promise-many-array.d.ts.map

package/declarations/model/-private/record-state.d.ts

@@ -1,9 +1,9 @@
-import type { Store } from '@warp-drive/core';
-import type { RequestCacheRequestState, RequestStateService } from '@warp-drive/core/store/-private';
-import type { Cache } from '@warp-drive/core/types/cache';
-import type { StableRecordIdentifier } from '@warp-drive/core/types/identifier';
-import type { Errors } from './errors';
-import type { MinimalLegacyRecord } from './model-methods';
+import type { Store } from "@warp-drive/core";
+import type { RequestCacheRequestState, RequestStateService } from "@warp-drive/core/store/-private";
+import type { Cache } from "@warp-drive/core/types/cache";
+import type { StableRecordIdentifier } from "@warp-drive/core/types/identifier";
+import type { Errors } from "./errors.js";
+import type { MinimalLegacyRecord } from "./model-methods.js";
 /**
 Historically EmberData managed a state machine
 for each record, the localState for which
@@ -15,64 +15,67 @@ 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
+empty
+deleted    // hidden from stateName
+preloaded  // hidden from stateName
 
-  loading
-     empty     // 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
+loaded
+saved
+updated
+uncommitted
+invalid
+inFlight
+created
+uncommitted
+invalid
+inFlight
 
-  deleted
-    saved
-      new      // hidden from stateName
-    uncommitted
-    invalid
-    inFlight
+deleted
+saved
+new      // hidden from stateName
+uncommitted
+invalid
+inFlight
 
-  @internal
+@internal
 */
 export default class RecordState {
-    store: Store;
-    identifier: StableRecordIdentifier;
-    record: MinimalLegacyRecord;
-    rs: RequestStateService;
-    pendingCount: number;
-    fulfilledCount: number;
-    rejectedCount: number;
-    cache: Cache;
-    _errorRequests: RequestCacheRequestState[];
-    _lastError: RequestCacheRequestState | null;
-    handler: object;
-    constructor(record: MinimalLegacyRecord);
-    destroy(): void;
-    notify(key: keyof this & string): void;
-    updateInvalidErrors(errors: Errors): void;
-    cleanErrorRequests(): void;
-    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(): "" | "updated" | "deleted" | "created";
+	store: Store;
+	identifier: StableRecordIdentifier;
+	record: MinimalLegacyRecord;
+	rs: RequestStateService;
+	pendingCount: number;
+	fulfilledCount: number;
+	rejectedCount: number;
+	cache: Cache;
+	_errorRequests: RequestCacheRequestState[];
+	_lastError: RequestCacheRequestState | null;
+	handler: object;
+	constructor(record: MinimalLegacyRecord);
+	/** @internal */
+	destroy(): void;
+	/** @internal */
+	notify(key: keyof this & string): void;
+	/** @internal */
+	updateInvalidErrors(errors: Errors): void;
+	/** @internal */
+	cleanErrorRequests(): void;
+	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";
 }
-//# sourceMappingURL=record-state.d.ts.map