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

package/declarations/model.d.ts

@@ -1,50 +1,49 @@
 /**
- * This package provides a Presentation Model for resource data in an WarpDrive Cache.
- *
- * Models are defined as classes extending from `import Model from '@ember-data/model';` and the
- * attributes and relationships on these classes are parsed at runtime to supply static "schema"
- * to WarpDrive's SchemaService.
- *
- * Resource data for individual resources fetched from your API is presented to the UI via instances
- * of the `Model`s you define. An instantiated `Model` is referred to as a `record`.
-
-  When we refer to the `ModelClass` as opposed to a `Model` or `Record` we are referring
-  specifically to the class definition and the static schema methods present on it.
-
-  When we refer to a `record` we refer to a specific class instance presenting
-  the resource data for a given `type` and `id`.
-
-  ### Defining a Model
-
-  ```js [app/models/person.js]
-  import Model, { attr, belongsTo, hasMany } from '@ember-data/model';
-
-  export default class PersonModel extends Model {
-    @attr name;
-
-    @belongsTo('pet', { inverse: 'owners', async: false }) dog;
-
-    @hasMany('person', { inverse: 'friends', async: true }) friends;
-  }
-  ```
-
-  ### modelName convention
-
-  By convention, the name of a given model (its `type`) matches the name
-  of the file in the `app/models` folder and should be lowercase, singular
-  and dasherized.
-
-  @module
- */
-export { attr } from './model/-private/attr';
-export { belongsTo } from './model/-private/belongs-to';
-export { hasMany } from './model/-private/has-many';
-export { Model } from './model/-private/model';
-export { Model as default } from './model/-private/model';
-export type { PromiseBelongsTo as AsyncBelongsTo } from './model/-private/promise-belongs-to';
-export type { PromiseManyArray as AsyncHasMany } from './model/-private/promise-many-array';
-export type { RelatedCollection as ManyArray } from '@warp-drive/core/store/-private';
-export type { RelatedCollection as HasMany } from '@warp-drive/core/store/-private';
-export { instantiateRecord, teardownRecord, modelFor } from './model/-private/hooks';
-export { buildSchema } from './model/-private/schema-provider';
-//# sourceMappingURL=model.d.ts.map
+* This package provides a Presentation Model for resource data in an WarpDrive Cache.
+*
+* Models are defined as classes extending from `import Model from '@ember-data/model';` and the
+* attributes and relationships on these classes are parsed at runtime to supply static "schema"
+* to WarpDrive's SchemaService.
+*
+* Resource data for individual resources fetched from your API is presented to the UI via instances
+* of the `Model`s you define. An instantiated `Model` is referred to as a `record`.
+
+When we refer to the `ModelClass` as opposed to a `Model` or `Record` we are referring
+specifically to the class definition and the static schema methods present on it.
+
+When we refer to a `record` we refer to a specific class instance presenting
+the resource data for a given `type` and `id`.
+
+### Defining a Model
+
+```js [app/models/person.js]
+import Model, { attr, belongsTo, hasMany } from '@ember-data/model';
+
+export default class PersonModel extends Model {
+@attr name;
+
+@belongsTo('pet', { inverse: 'owners', async: false }) dog;
+
+@hasMany('person', { inverse: 'friends', async: true }) friends;
+}
+```
+
+### modelName convention
+
+By convention, the name of a given model (its `type`) matches the name
+of the file in the `app/models` folder and should be lowercase, singular
+and dasherized.
+
+@module
+*/
+export { attr } from "./model/-private/attr.js";
+export { belongsTo } from "./model/-private/belongs-to.js";
+export { hasMany } from "./model/-private/has-many.js";
+export { Model } from "./model/-private/model.js";
+export { Model as default } from "./model/-private/model.js";
+export type { PromiseBelongsTo as AsyncBelongsTo } from "./model/-private/promise-belongs-to.js";
+export type { PromiseManyArray as AsyncHasMany } from "./model/-private/promise-many-array.js";
+export type { RelatedCollection as ManyArray } from "@warp-drive/core/store/-private";
+export type { RelatedCollection as HasMany } from "@warp-drive/core/store/-private";
+export { instantiateRecord, teardownRecord, modelFor } from "./model/-private/hooks.js";
+export { buildSchema } from "./model/-private/schema-provider.js";

package/declarations/serializer/-private/embedded-records-mixin.d.ts

@@ -1,97 +1,96 @@
+import Mixin from "@ember/object/mixin";
 /**
-  ## Using Embedded Records
+## Using Embedded Records
 
-  `EmbeddedRecordsMixin` supports serializing embedded records.
+`EmbeddedRecordsMixin` supports serializing embedded records.
 
-  To set up embedded records, include the mixin when extending a serializer,
-  then define and configure embedded (model) relationships.
+To set up embedded records, include the mixin when extending a serializer,
+then define and configure embedded (model) relationships.
 
-  Note that embedded records will serialize with the serializer for their model instead of the serializer in which they are defined.
+Note that embedded records will serialize with the serializer for their model instead of the serializer in which they are defined.
 
-  Note also that this mixin does not work with JSONAPISerializer because the JSON:API specification does not describe how to format embedded resources.
+Note also that this mixin does not work with JSONAPISerializer because the JSON:API specification does not describe how to format embedded resources.
 
-  Below is an example of a per-type serializer (`post` type).
+Below is an example of a per-type serializer (`post` type).
 
-  ```js [app/serializers/post.js]
-  import RESTSerializer, { EmbeddedRecordsMixin } from '@ember-data/serializer/rest';
+```js [app/serializers/post.js]
+import RESTSerializer, { EmbeddedRecordsMixin } from '@ember-data/serializer/rest';
 
-  export default class PostSerializer extends RESTSerializer.extend(EmbeddedRecordsMixin) {
-    attrs = {
-      author: { embedded: 'always' },
-      comments: { serialize: 'ids' }
-    }
-  }
-  ```
-  Note that this use of `{ embedded: 'always' }` is unrelated to
-  the `{ embedded: 'always' }` that is defined as an option on `attr` as part of
-  defining a model while working with the `ActiveModelSerializer`.  Nevertheless,
-  using `{ embedded: 'always' }` as an option to `attr` is not a valid way to set up
-  embedded records.
+export default class PostSerializer extends RESTSerializer.extend(EmbeddedRecordsMixin) {
+attrs = {
+author: { embedded: 'always' },
+comments: { serialize: 'ids' }
+}
+}
+```
+Note that this use of `{ embedded: 'always' }` is unrelated to
+the `{ embedded: 'always' }` that is defined as an option on `attr` as part of
+defining a model while working with the `ActiveModelSerializer`.  Nevertheless,
+using `{ embedded: 'always' }` as an option to `attr` is not a valid way to set up
+embedded records.
 
-  The `attrs` option for a resource `{ embedded: 'always' }` is shorthand for:
+The `attrs` option for a resource `{ embedded: 'always' }` is shorthand for:
 
-  ```js
-  {
-    serialize: 'records',
-    deserialize: 'records'
-  }
-  ```
+```js
+{
+serialize: 'records',
+deserialize: 'records'
+}
+```
 
-  ### Configuring Attrs
+### Configuring Attrs
 
-  A resource's `attrs` option may be set to use `ids`, `records` or false for the
-  `serialize`  and `deserialize` settings.
+A resource's `attrs` option may be set to use `ids`, `records` or false for the
+`serialize`  and `deserialize` settings.
 
-  The `attrs` property can be set on the `ApplicationSerializer` or a per-type
-  serializer.
+The `attrs` property can be set on the `ApplicationSerializer` or a per-type
+serializer.
 
-  In the case where embedded JSON is expected while extracting a payload (reading)
-  the setting is `deserialize: 'records'`, there is no need to use `ids` when
-  extracting as that is the default behaviour without this mixin if you are using
-  the vanilla `EmbeddedRecordsMixin`. Likewise, to embed JSON in the payload while
-  serializing `serialize: 'records'` is the setting to use. There is an option of
-  not embedding JSON in the serialized payload by using `serialize: 'ids'`. If you
-  do not want the relationship sent at all, you can use `serialize: false`.
+In the case where embedded JSON is expected while extracting a payload (reading)
+the setting is `deserialize: 'records'`, there is no need to use `ids` when
+extracting as that is the default behaviour without this mixin if you are using
+the vanilla `EmbeddedRecordsMixin`. Likewise, to embed JSON in the payload while
+serializing `serialize: 'records'` is the setting to use. There is an option of
+not embedding JSON in the serialized payload by using `serialize: 'ids'`. If you
+do not want the relationship sent at all, you can use `serialize: false`.
 
 
-  ### EmbeddedRecordsMixin defaults
-  If you do not overwrite `attrs` for a specific relationship, the `EmbeddedRecordsMixin`
-  will behave in the following way:
+### EmbeddedRecordsMixin defaults
+If you do not overwrite `attrs` for a specific relationship, the `EmbeddedRecordsMixin`
+will behave in the following way:
 
-  BelongsTo: `{ serialize: 'id', deserialize: 'id' }`
-  HasMany:   `{ serialize: false, deserialize: 'ids' }`
+BelongsTo: `{ serialize: 'id', deserialize: 'id' }`
+HasMany:   `{ serialize: false, deserialize: 'ids' }`
 
-  ### Model Relationships
+### Model Relationships
 
-  Embedded records must have a model defined to be extracted and serialized. Note that
-  when defining any relationships on your model such as `belongsTo` and `hasMany`, you
-  should not both specify `async: true` and also indicate through the serializer's
-  `attrs` attribute that the related model should be embedded for deserialization.
-  If a model is declared embedded for deserialization (`embedded: 'always'` or `deserialize: 'records'`),
-  then do not use `async: true`.
+Embedded records must have a model defined to be extracted and serialized. Note that
+when defining any relationships on your model such as `belongsTo` and `hasMany`, you
+should not both specify `async: true` and also indicate through the serializer's
+`attrs` attribute that the related model should be embedded for deserialization.
+If a model is declared embedded for deserialization (`embedded: 'always'` or `deserialize: 'records'`),
+then do not use `async: true`.
 
-  To successfully extract and serialize embedded records the model relationships
-  must be set up correctly. See the
-  [defining relationships](https://guides.emberjs.com/current/models/relationships)
-  section of the **Defining Models** guide page.
+To successfully extract and serialize embedded records the model relationships
+must be set up correctly. See the
+[defining relationships](https://guides.emberjs.com/current/models/relationships)
+section of the **Defining Models** guide page.
 
-  Records without an `id` property are not considered embedded records, model
-  instances must have an `id` property to be used with Ember Data.
+Records without an `id` property are not considered embedded records, model
+instances must have an `id` property to be used with Ember Data.
 
-  ### Example JSON payloads, Models and Serializers
+### Example JSON payloads, Models and Serializers
 
-  **When customizing a serializer it is important to grok what the customizations
-  are. Please read the docs for the methods this mixin provides, in case you need
-  to modify it to fit your specific needs.**
+**When customizing a serializer it is important to grok what the customizations
+are. Please read the docs for the methods this mixin provides, in case you need
+to modify it to fit your specific needs.**
 
-  For example, review the docs for each method of this mixin:
-  * [normalize](/ember-data/release/classes/EmbeddedRecordsMixin/methods/normalize?anchor=normalize)
-  * [serializeBelongsTo](/ember-data/release/classes/EmbeddedRecordsMixin/methods/serializeBelongsTo?anchor=serializeBelongsTo)
-  * [serializeHasMany](/ember-data/release/classes/EmbeddedRecordsMixin/methods/serializeHasMany?anchor=serializeHasMany)
+For example, review the docs for each method of this mixin:
+* [normalize](/ember-data/release/classes/EmbeddedRecordsMixin/methods/normalize?anchor=normalize)
+* [serializeBelongsTo](/ember-data/release/classes/EmbeddedRecordsMixin/methods/serializeBelongsTo?anchor=serializeBelongsTo)
+* [serializeHasMany](/ember-data/release/classes/EmbeddedRecordsMixin/methods/serializeHasMany?anchor=serializeHasMany)
 
-  @class EmbeddedRecordsMixin
-  @public
+@class EmbeddedRecordsMixin
+@public
 */
-export const EmbeddedRecordsMixin: Mixin;
-import Mixin from '@ember/object/mixin';
-//# sourceMappingURL=embedded-records-mixin.d.ts.map
+export declare const EmbeddedRecordsMixin: Mixin;

package/declarations/serializer/-private/transforms/boolean.d.ts

@@ -1,47 +1,47 @@
-import type { TransformName } from '@warp-drive/core/types/symbols';
+import type { TransformName } from "@warp-drive/core/types/symbols";
+export interface BooleanTransform {
+	[TransformName]: "boolean";
+}
 /**
-  The `BooleanTransform` class is used to serialize and deserialize
-  boolean attributes on Ember Data record objects. This transform is
-  used when `boolean` is passed as the type parameter to the
-  [attr](/ember-data/release/functions/@ember-data%2Fmodel/attr) function.
+The `BooleanTransform` class is used to serialize and deserialize
+boolean attributes on Ember Data record objects. This transform is
+used when `boolean` is passed as the type parameter to the
+[attr](/ember-data/release/functions/@ember-data%2Fmodel/attr) function.
 
-  Usage
+Usage
 
-  ```js [app/models/user.js]
-  import { Model, attr } from '@warp-drive/legacy/model';
+```js [app/models/user.js]
+import { Model, attr } from '@warp-drive/legacy/model';
 
-  export default class UserModel extends Model {
-    @attr('boolean') isAdmin;
-    @attr('string') name;
-    @attr('string') email;
-  }
-  ```
+export default class UserModel extends Model {
+@attr('boolean') isAdmin;
+@attr('string') name;
+@attr('string') email;
+}
+```
 
-  By default, the boolean transform only allows for values of `true` or
-  `false`. You can opt into allowing `null` values for
-  boolean attributes via `attr('boolean', { allowNull: true })`
+By default, the boolean transform only allows for values of `true` or
+`false`. You can opt into allowing `null` values for
+boolean attributes via `attr('boolean', { allowNull: true })`
 
-  ```js [app/models/user.js]
-  import { Model, attr } from '@warp-drive/legacy/model';
+```js [app/models/user.js]
+import { Model, attr } from '@warp-drive/legacy/model';
 
-  export default class UserModel extends Model {
-    @attr('string') email;
-    @attr('string') username;
-    @attr('boolean', { allowNull: true }) wantsWeeklyEmail;
-  }
-  ```
+export default class UserModel extends Model {
+@attr('string') email;
+@attr('string') username;
+@attr('boolean', { allowNull: true }) wantsWeeklyEmail;
+}
+```
 
-  @class BooleanTransform
-  @public
- */
+@public
+*/
 export declare class BooleanTransform {
-    deserialize(serialized: boolean | null | number | string, options?: {
-        allowNull?: boolean;
-    }): boolean | null;
-    serialize(deserialized: boolean | null, options?: {
-        allowNull?: boolean;
-    }): boolean | null;
-    [TransformName]: 'boolean';
-    static create(): BooleanTransform;
+	deserialize(serialized: boolean | null | number | string, options?: {
+		allowNull?: boolean;
+	}): boolean | null;
+	serialize(deserialized: boolean | null, options?: {
+		allowNull?: boolean;
+	}): boolean | null;
+	static create(): BooleanTransform;
 }
-//# sourceMappingURL=boolean.d.ts.map

package/declarations/serializer/-private/transforms/date.d.ts

@@ -1,28 +1,28 @@
-import { TransformName } from '@warp-drive/core/types/symbols';
+import type { TransformName } from "@warp-drive/core/types/symbols";
+export interface DateTransform {
+	[TransformName]: "date";
+}
 /**
- The `DateTransform` class is used to serialize and deserialize
- date attributes on Ember Data record objects. This transform is used
- when `date` is passed as the type parameter to the
- [attr](/ember-data/release/functions/@ember-data%2Fmodel/attr) function. It uses the [`ISO 8601`](https://en.wikipedia.org/wiki/ISO_8601)
- standard.
+The `DateTransform` class is used to serialize and deserialize
+date attributes on Ember Data record objects. This transform is used
+when `date` is passed as the type parameter to the
+[attr](/ember-data/release/functions/@ember-data%2Fmodel/attr) function. It uses the [`ISO 8601`](https://en.wikipedia.org/wiki/ISO_8601)
+standard.
 
- ```js [app/models/score.js]
- import Model, { attr, belongsTo } from '@ember-data/model';
+```js [app/models/score.js]
+import Model, { attr, belongsTo } from '@ember-data/model';
 
- export default class ScoreModel extends Model {
-    @attr('number') value;
-    @belongsTo('player') player;
-    @attr('date') date;
-  }
- ```
+export default class ScoreModel extends Model {
+@attr('number') value;
+@belongsTo('player') player;
+@attr('date') date;
+}
+```
 
- @class DateTransform
-  @public
- */
+@public
+*/
 export declare class DateTransform {
-    deserialize(serialized: string | number | null, _options?: Record<string, unknown>): Date | null;
-    serialize(date: Date, _options?: Record<string, unknown>): string | null;
-    [TransformName]: "date";
-    static create(): DateTransform;
+	deserialize(serialized: string | number | null, _options?: Record<string, unknown>): Date | null;
+	serialize(date: Date, _options?: Record<string, unknown>): string | null;
+	static create(): DateTransform;
 }
-//# sourceMappingURL=date.d.ts.map

package/declarations/serializer/-private/transforms/number.d.ts

@@ -1,29 +1,29 @@
-import { TransformName } from '@warp-drive/core/types/symbols';
+import type { TransformName } from "@warp-drive/core/types/symbols";
+export interface NumberTransform {
+	[TransformName]: "number";
+}
 /**
-  The `NumberTransform` class is used to serialize and deserialize
-  numeric attributes on Ember Data record objects. This transform is
-  used when `number` is passed as the type parameter to the
-  [attr](/ember-data/release/functions/@ember-data%2Fmodel/attr) function.
+The `NumberTransform` class is used to serialize and deserialize
+numeric attributes on Ember Data record objects. This transform is
+used when `number` is passed as the type parameter to the
+[attr](/ember-data/release/functions/@ember-data%2Fmodel/attr) function.
 
-  Usage
+Usage
 
-  ```js [app/models/score.js]
-  import Model, { attr, belongsTo } from '@ember-data/model';
+```js [app/models/score.js]
+import Model, { attr, belongsTo } from '@ember-data/model';
 
-  export default class ScoreModel extends Model {
-    @attr('number') value;
-    @belongsTo('player') player;
-    @attr('date') date;
-  }
-  ```
+export default class ScoreModel extends Model {
+@attr('number') value;
+@belongsTo('player') player;
+@attr('date') date;
+}
+```
 
-  @class NumberTransform
-  @public
- */
+@public
+*/
 export declare class NumberTransform {
-    deserialize(serialized: string | number | null | undefined, _options?: Record<string, unknown>): number | null;
-    serialize(deserialized: string | number | null | undefined, _options?: Record<string, unknown>): number | null;
-    [TransformName]: "number";
-    static create(): NumberTransform;
+	deserialize(serialized: string | number | null | undefined, _options?: Record<string, unknown>): number | null;
+	serialize(deserialized: string | number | null | undefined, _options?: Record<string, unknown>): number | null;
+	static create(): NumberTransform;
 }
-//# sourceMappingURL=number.d.ts.map

package/declarations/serializer/-private/transforms/string.d.ts

@@ -1,29 +1,29 @@
-import { TransformName } from '@warp-drive/core/types/symbols';
+import type { TransformName } from "@warp-drive/core/types/symbols";
+export interface StringTransform {
+	[TransformName]: "string";
+}
 /**
-  The `StringTransform` class is used to serialize and deserialize
-  string attributes on Ember Data record objects. This transform is
-  used when `string` is passed as the type parameter to the
-  [attr](/ember-data/release/functions/@ember-data%2Fmodel/attr) function.
+The `StringTransform` class is used to serialize and deserialize
+string attributes on Ember Data record objects. This transform is
+used when `string` is passed as the type parameter to the
+[attr](/ember-data/release/functions/@ember-data%2Fmodel/attr) function.
 
-  Usage
+Usage
 
-  ```js [app/models/user.js]
-  import Model, { attr, belongsTo } from '@ember-data/model';
+```js [app/models/user.js]
+import Model, { attr, belongsTo } from '@ember-data/model';
 
-  export default class UserModel extends Model {
-    @attr('boolean') isAdmin;
-    @attr('string') name;
-    @attr('string') email;
-  }
-  ```
+export default class UserModel extends Model {
+@attr('boolean') isAdmin;
+@attr('string') name;
+@attr('string') email;
+}
+```
 
-  @class StringTransform
-  @public
- */
+@public
+*/
 export declare class StringTransform {
-    deserialize(serialized: unknown, _options?: Record<string, unknown>): string | null;
-    serialize(deserialized: unknown, _options?: Record<string, unknown>): string | null;
-    [TransformName]: "string";
-    static create(): StringTransform;
+	deserialize(serialized: unknown, _options?: Record<string, unknown>): string | null;
+	serialize(deserialized: unknown, _options?: Record<string, unknown>): string | null;
+	static create(): StringTransform;
 }
-//# sourceMappingURL=string.d.ts.map