\n \n ## Success and failure\n \n The JSONAPIAdapter will consider a success any response with a\n status code of the 2xx family (\"Success\"), as well as 304 (\"Not\n Modified\"). Any other status code will be considered a failure.\n \n On success, the request promise will be resolved with the full\n response payload.\n \n Failed responses with status code 422 (\"Unprocessable Entity\") will\n be considered \"invalid\". The response will be discarded, except for\n the `errors` key. The request promise will be rejected with a\n `InvalidError`. This error object will encapsulate the saved\n `errors` value.\n \n Any other status codes will be treated as an adapter error. The\n request promise will be rejected, similarly to the invalid case,\n but with an instance of `AdapterError` instead.\n \n ### Endpoint path customization\n \n Endpoint paths can be prefixed with a `namespace` by setting the\n namespace property on the adapter:\n \n ```app/adapters/application.js\n import JSONAPIAdapter from '@ember-data/adapter/json-api';\n \n export default class ApplicationAdapter extends JSONAPIAdapter {\n namespace = 'api/1';\n }\n ```\n Requests for the `person` model would now target `/api/1/people/1`.\n \n ### Host customization\n \n An adapter can target other hosts by setting the `host` property.\n \n ```app/adapters/application.js\n import JSONAPIAdapter from '@ember-data/adapter/json-api';\n \n export default class ApplicationAdapter extends JSONAPIAdapter {\n host = 'https://api.example.com';\n }\n ```\n \n Requests for the `person` model would now target\n `https://api.example.com/people/1`.\n \n @since 1.13.0\n @class JSONAPIAdapter\n @main @ember-data/adapter/json-api\n @public\n @constructor\n @extends RESTAdapter\n */\n class JSONAPIAdapter extends _rest.default {\n constructor(...args) {\n super(...args);\n this._defaultContentType = 'application/vnd.api+json';\n }\n /**\n @method ajaxOptions\n @private\n @param {String} url\n @param {String} type The request type GET, POST, PUT, DELETE etc.\n @param {Object} options\n @return {Object}\n */\n ajaxOptions(url, type, options = {}) {\n let hash = super.ajaxOptions(url, type, options);\n hash.headers['Accept'] = hash.headers['Accept'] || 'application/vnd.api+json';\n return hash;\n }\n\n /**\n By default the JSONAPIAdapter will send each find request coming from a `store.find`\n or from accessing a relationship separately to the server. If your server supports passing\n ids as a query string, you can set coalesceFindRequests to true to coalesce all find requests\n within a single runloop.\n For example, if you have an initial payload of:\n ```javascript\n {\n data: {\n id: 1,\n type: 'post',\n relationship: {\n comments: {\n data: [\n { id: 1, type: 'comment' },\n { id: 2, type: 'comment' }\n ]\n }\n }\n }\n }\n ```\n By default calling `post.get('comments')` will trigger the following requests(assuming the\n comments haven't been loaded before):\n ```\n GET /comments/1\n GET /comments/2\n ```\n If you set coalesceFindRequests to `true` it will instead trigger the following request:\n ```\n GET /comments?filter[id]=1,2\n ```\n Setting coalesceFindRequests to `true` also works for `store.find` requests and `belongsTo`\n relationships accessed within the same runloop. If you set `coalesceFindRequests: true`\n ```javascript\n store.findRecord('comment', 1);\n store.findRecord('comment', 2);\n ```\n will also send a request to: `GET /comments?filter[id]=1,2`\n Note: Requests coalescing rely on URL building strategy. So if you override `buildURL` in your app\n `groupRecordsForFindMany` more likely should be overridden as well in order for coalescing to work.\n @property coalesceFindRequests\n @public\n @type {boolean}\n */\n get coalesceFindRequests() {\n let coalesceFindRequests = this._coalesceFindRequests;\n if (typeof coalesceFindRequests === 'boolean') {\n return coalesceFindRequests;\n }\n return this._coalesceFindRequests = false;\n }\n set coalesceFindRequests(value) {\n this._coalesceFindRequests = value;\n }\n findMany(store, type, ids, snapshots) {\n let url = this.buildURL(type.modelName, ids, snapshots, 'findMany');\n return this.ajax(url, 'GET', {\n data: {\n filter: {\n id: ids.join(',')\n }\n }\n });\n }\n pathForType(modelName) {\n let dasherized = (0, _string.dasherize)(modelName);\n return (0, _emberInflector.pluralize)(dasherized);\n }\n updateRecord(store, schema, snapshot) {\n const data = (0, _private.serializeIntoHash)(store, schema, snapshot);\n const type = snapshot.modelName;\n const id = snapshot.id;\n (true && !(typeof id === 'string' && id.length > 0) && (0, _debug.assert)(`Attempted to update the ${type} record, but the record has no id`, typeof id === 'string' && id.length > 0));\n let url = this.buildURL(type, id, snapshot, 'updateRecord');\n return this.ajax(url, 'PATCH', {\n data: data\n });\n }\n }\n var _default = _exports.default = JSONAPIAdapter;\n});","define(\"@ember-data/adapter/rest\", [\"exports\", \"@ember/application\", \"@ember/debug\", \"@ember/object\", \"@ember/runloop\", \"rsvp\", \"@ember-data/adapter/-private\", \"@ember-data/adapter/error\", \"@ember-data/adapter/index\"], function (_exports, _application, _debug, _object, _runloop, _rsvp, _private, _error, _index) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.default = void 0;\n _exports.fetchOptions = fetchOptions;\n var _dec, _class;\n /**\n @module @ember-data/adapter/rest\n */\n 0; //eaimeta@70e063a35619d71f0,\"@ember/application\",0,\"@ember/debug\",0,\"@ember/object\",0,\"@ember/runloop\",0,\"@glimmer/env\",0,\"rsvp\",0,\"@ember-data/adapter/-private\",0,\"@ember-data/adapter/error\",0,\"@ember-data/adapter/index\"eaimeta@70e063a35619d71f\n function _applyDecoratedDescriptor(i, e, r, n, l) { var a = {}; return Object.keys(n).forEach(function (i) { a[i] = n[i]; }), a.enumerable = !!a.enumerable, a.configurable = !!a.configurable, (\"value\" in a || a.initializer) && (a.writable = !0), a = r.slice().reverse().reduce(function (r, n) { return n(i, e, r) || r; }, a), l && void 0 !== a.initializer && (a.value = a.initializer ? a.initializer.call(l) : void 0, a.initializer = void 0), void 0 === a.initializer ? (Object.defineProperty(i, e, a), null) : a; }\n /**\n The REST adapter allows your store to communicate with an HTTP server by\n transmitting JSON via XHR. Most Ember.js apps that consume a JSON API\n should use the REST adapter.\n \n This adapter is designed around the idea that the JSON exchanged with\n the server should be conventional.\n \n ## Success and failure\n \n The REST adapter will consider a success any response with a status code\n of the 2xx family (\"Success\"), as well as 304 (\"Not Modified\"). Any other\n status code will be considered a failure.\n \n On success, the request promise will be resolved with the full response\n payload.\n \n Failed responses with status code 422 (\"Unprocessable Entity\") will be\n considered \"invalid\". The response will be discarded, except for the\n `errors` key. The request promise will be rejected with a `InvalidError`.\n This error object will encapsulate the saved `errors` value.\n \n Any other status codes will be treated as an \"adapter error\". The request\n promise will be rejected, similarly to the \"invalid\" case, but with\n an instance of `AdapterError` instead.\n \n ## JSON Structure\n \n The REST adapter expects the JSON returned from your server to follow\n these conventions.\n \n ### Object Root\n \n The JSON payload should be an object that contains the record inside a\n root property. For example, in response to a `GET` request for\n `/posts/1`, the JSON should look like this:\n \n ```js\n {\n \"posts\": {\n \"id\": 1,\n \"title\": \"I'm Running to Reform the W3C's Tag\",\n \"author\": \"Yehuda Katz\"\n }\n }\n ```\n \n Similarly, in response to a `GET` request for `/posts`, the JSON should\n look like this:\n \n ```js\n {\n \"posts\": [\n {\n \"id\": 1,\n \"title\": \"I'm Running to Reform the W3C's Tag\",\n \"author\": \"Yehuda Katz\"\n },\n {\n \"id\": 2,\n \"title\": \"Rails is omakase\",\n \"author\": \"D2H\"\n }\n ]\n }\n ```\n \n Note that the object root can be pluralized for both a single-object response\n and an array response: the REST adapter is not strict on this. Further, if the\n HTTP server responds to a `GET` request to `/posts/1` (e.g. the response to a\n `findRecord` query) with more than one object in the array, Ember Data will\n only display the object with the matching ID.\n \n ### Conventional Names\n \n Attribute names in your JSON payload should be the camelCased versions of\n the attributes in your Ember.js models.\n \n For example, if you have a `Person` model:\n \n ```app/models/person.js\n import Model, { attr } from '@ember-data/model';\n \n export default Model.extend({\n firstName: attr('string'),\n lastName: attr('string'),\n occupation: attr('string')\n });\n ```\n \n The JSON returned should look like this:\n \n ```js\n {\n \"people\": {\n \"id\": 5,\n \"firstName\": \"Zaphod\",\n \"lastName\": \"Beeblebrox\",\n \"occupation\": \"President\"\n }\n }\n ```\n \n #### Relationships\n \n Relationships are usually represented by ids to the record in the\n relationship. The related records can then be sideloaded in the\n response under a key for the type.\n \n ```js\n {\n \"posts\": {\n \"id\": 5,\n \"title\": \"I'm Running to Reform the W3C's Tag\",\n \"author\": \"Yehuda Katz\",\n \"comments\": [1, 2]\n },\n \"comments\": [{\n \"id\": 1,\n \"author\": \"User 1\",\n \"message\": \"First!\",\n }, {\n \"id\": 2,\n \"author\": \"User 2\",\n \"message\": \"Good Luck!\",\n }]\n }\n ```\n \n If the records in the relationship are not known when the response\n is serialized it's also possible to represent the relationship as a\n URL using the `links` key in the response. Ember Data will fetch\n this URL to resolve the relationship when it is accessed for the\n first time.\n \n ```js\n {\n \"posts\": {\n \"id\": 5,\n \"title\": \"I'm Running to Reform the W3C's Tag\",\n \"author\": \"Yehuda Katz\",\n \"links\": {\n \"comments\": \"/posts/5/comments\"\n }\n }\n }\n ```\n \n ### Errors\n \n If a response is considered a failure, the JSON payload is expected to include\n a top-level key `errors`, detailing any specific issues. For example:\n \n ```js\n {\n \"errors\": {\n \"msg\": \"Something went wrong\"\n }\n }\n ```\n \n This adapter does not make any assumptions as to the format of the `errors`\n object. It will simply be passed along as is, wrapped in an instance\n of `InvalidError` or `AdapterError`. The serializer can interpret it\n afterwards.\n \n ## Customization\n \n ### Endpoint path customization\n \n Endpoint paths can be prefixed with a `namespace` by setting the namespace\n property on the adapter:\n \n ```app/adapters/application.js\n import RESTAdapter from '@ember-data/adapter/rest';\n \n export default class ApplicationAdapter extends RESTAdapter {\n namespace = 'api/1';\n }\n ```\n Requests for the `Person` model would now target `/api/1/people/1`.\n \n ### Host customization\n \n An adapter can target other hosts by setting the `host` property.\n \n ```app/adapters/application.js\n import RESTAdapter from '@ember-data/adapter/rest';\n \n export default class ApplicationAdapter extends RESTAdapter {\n host = 'https://api.example.com';\n }\n ```\n \n ### Headers customization\n \n Some APIs require HTTP headers, e.g. to provide an API key. Arbitrary\n headers can be set as key/value pairs on the `RESTAdapter`'s `headers`\n object and Ember Data will send them along with each ajax request.\n \n \n ```app/adapters/application.js\n import RESTAdapter from '@ember-data/adapter/rest';\n import { computed } from '@ember/object';\n \n export default class ApplicationAdapter extends RESTAdapter {\n headers: computed(function() {\n return {\n 'API_KEY': 'secret key',\n 'ANOTHER_HEADER': 'Some header value'\n };\n }\n }\n ```\n \n `headers` can also be used as a computed property to support dynamic\n headers. In the example below, the `session` object has been\n injected into an adapter by Ember's container.\n \n ```app/adapters/application.js\n import RESTAdapter from '@ember-data/adapter/rest';\n import { computed } from '@ember/object';\n \n export default class ApplicationAdapter extends RESTAdapter {\n headers: computed('session.authToken', function() {\n return {\n 'API_KEY': this.get('session.authToken'),\n 'ANOTHER_HEADER': 'Some header value'\n };\n })\n }\n ```\n \n In some cases, your dynamic headers may require data from some\n object outside of Ember's observer system (for example\n `document.cookie`). You can use the\n [volatile](/api/classes/Ember.ComputedProperty.html?anchor=volatile)\n function to set the property into a non-cached mode causing the headers to\n be recomputed with every request.\n \n ```app/adapters/application.js\n import RESTAdapter from '@ember-data/adapter/rest';\n import { get } from '@ember/object';\n import { computed } from '@ember/object';\n \n export default class ApplicationAdapter extends RESTAdapter {\n headers: computed(function() {\n return {\n 'API_KEY': get(document.cookie.match(/apiKey\\=([^;]*)/), '1'),\n 'ANOTHER_HEADER': 'Some header value'\n };\n }).volatile()\n }\n ```\n \n @class RESTAdapter\n @main @ember-data/adapter/rest\n @public\n @constructor\n @extends Adapter\n @uses BuildURLMixin\n */\n let RESTAdapter = (_dec = (0, _object.computed)(), _class = class RESTAdapter extends _index.default.extend(_index.BuildURLMixin) {\n constructor(...args) {\n super(...args);\n /**\n This property allows ajax to still be used instead when `false`.\n @property useFetch\n @type {Boolean}\n @default true\n @public\n */\n this.useFetch = true;\n this._defaultContentType = 'application/json; charset=utf-8';\n // http://stackoverflow.com/questions/417142/what-is-the-maximum-length-of-a-url-in-different-browsers\n this.maxURLLength = 2048;\n }\n get fastboot() {\n // Avoid computed property override deprecation in fastboot as suggested by:\n // https://deprecations.emberjs.com/v3.x/#toc_computed-property-override\n let fastboot = this._fastboot;\n if (fastboot) {\n return fastboot;\n }\n return this._fastboot = (0, _application.getOwner)(this).lookup('service:fastboot');\n }\n set fastboot(value) {\n this._fastboot = value;\n }\n\n /**\n By default, the RESTAdapter will send the query params sorted alphabetically to the\n server.\n For example:\n ```js\n store.query('posts', { sort: 'price', category: 'pets' });\n ```\n will generate a requests like this `/posts?category=pets&sort=price`, even if the\n parameters were specified in a different order.\n That way the generated URL will be deterministic and that simplifies caching mechanisms\n in the backend.\n Setting `sortQueryParams` to a falsey value will respect the original order.\n In case you want to sort the query parameters with a different criteria, set\n `sortQueryParams` to your custom sort function.\n ```app/adapters/application.js\n import RESTAdapter from '@ember-data/adapter/rest';\n export default class ApplicationAdapter extends RESTAdapter {\n sortQueryParams(params) {\n let sortedKeys = Object.keys(params).sort().reverse();\n let len = sortedKeys.length, newParams = {};\n for (let i = 0; i < len; i++) {\n newParams[sortedKeys[i]] = params[sortedKeys[i]];\n }\n return newParams;\n }\n }\n ```\n @method sortQueryParams\n @param {Object} obj\n @return {Object}\n @public\n */\n sortQueryParams(obj) {\n let keys = Object.keys(obj);\n let len = keys.length;\n if (len < 2) {\n return obj;\n }\n let newQueryParams = {};\n let sortedKeys = keys.sort();\n for (let i = 0; i < len; i++) {\n newQueryParams[sortedKeys[i]] = obj[sortedKeys[i]];\n }\n return newQueryParams;\n }\n\n /**\n By default the RESTAdapter will send each find request coming from a `store.find`\n or from accessing a relationship separately to the server. If your server supports passing\n ids as a query string, you can set coalesceFindRequests to true to coalesce all find requests\n within a single runloop.\n For example, if you have an initial payload of:\n ```javascript\n {\n post: {\n id: 1,\n comments: [1, 2]\n }\n }\n ```\n By default calling `post.get('comments')` will trigger the following requests(assuming the\n comments haven't been loaded before):\n ```\n GET /comments/1\n GET /comments/2\n ```\n If you set coalesceFindRequests to `true` it will instead trigger the following request:\n ```\n GET /comments?ids[]=1&ids[]=2\n ```\n Setting coalesceFindRequests to `true` also works for `store.find` requests and `belongsTo`\n relationships accessed within the same runloop. If you set `coalesceFindRequests: true`\n ```javascript\n store.findRecord('comment', 1);\n store.findRecord('comment', 2);\n ```\n will also send a request to: `GET /comments?ids[]=1&ids[]=2`\n Note: Requests coalescing rely on URL building strategy. So if you override `buildURL` in your app\n `groupRecordsForFindMany` more likely should be overridden as well in order for coalescing to work.\n @property coalesceFindRequests\n @public\n @type {boolean}\n */\n get coalesceFindRequests() {\n let coalesceFindRequests = this._coalesceFindRequests;\n if (typeof coalesceFindRequests === 'boolean') {\n return coalesceFindRequests;\n }\n return this._coalesceFindRequests = false;\n }\n set coalesceFindRequests(value) {\n this._coalesceFindRequests = value;\n }\n\n /**\n Endpoint paths can be prefixed with a `namespace` by setting the namespace\n property on the adapter:\n ```app/adapters/application.js\n import RESTAdapter from '@ember-data/adapter/rest';\n export default class ApplicationAdapter extends RESTAdapter {\n namespace = 'api/1';\n }\n ```\n Requests for the `Post` model would now target `/api/1/post/`.\n @property namespace\n @public\n @type {String}\n */\n\n /**\n An adapter can target other hosts by setting the `host` property.\n ```app/adapters/application.js\n import RESTAdapter from '@ember-data/adapter/rest';\n export default class ApplicationAdapter extends RESTAdapter {\n host = 'https://api.example.com';\n }\n ```\n Requests for the `Post` model would now target `https://api.example.com/post/`.\n @property host\n @public\n @type {String}\n */\n\n /**\n Some APIs require HTTP headers, e.g. to provide an API\n key. Arbitrary headers can be set as key/value pairs on the\n `RESTAdapter`'s `headers` object and Ember Data will send them\n along with each ajax request. For dynamic headers see [headers\n customization](/ember-data/release/classes/RESTAdapter).\n ```app/adapters/application.js\n import RESTAdapter from '@ember-data/adapter/rest';\n import { computed } from '@ember/object';\n export default class ApplicationAdapter extends RESTAdapter {\n headers: computed(function() {\n return {\n 'API_KEY': 'secret key',\n 'ANOTHER_HEADER': 'Some header value'\n };\n })\n }\n ```\n @property headers\n @public\n @type {Object}\n */\n\n /**\n Called by the store in order to fetch the JSON for a given\n type and ID.\n The `findRecord` method makes an Ajax request to a URL computed by\n `buildURL`, and returns a promise for the resulting payload.\n This method performs an HTTP `GET` request with the id provided as part of the query string.\n @since 1.13.0\n @method findRecord\n @public\n @param {Store} store\n @param {Model} type\n @param {String} id\n @param {Snapshot} snapshot\n @return {Promise} promise\n */\n findRecord(store, type, id, snapshot) {\n let url = this.buildURL(type.modelName, id, snapshot, 'findRecord');\n let query = this.buildQuery(snapshot);\n return this.ajax(url, 'GET', {\n data: query\n });\n }\n\n /**\n Called by the store in order to fetch a JSON array for all\n of the records for a given type.\n The `findAll` method makes an Ajax (HTTP GET) request to a URL computed by `buildURL`, and returns a\n promise for the resulting payload.\n @method findAll\n @public\n @param {Store} store\n @param {Model} type\n @param {undefined} neverSet a value is never provided to this argument\n @param {SnapshotRecordArray} snapshotRecordArray\n @return {Promise} promise\n */\n findAll(store, type, sinceToken, snapshotRecordArray) {\n let query = this.buildQuery(snapshotRecordArray);\n let url = this.buildURL(type.modelName, null, snapshotRecordArray, 'findAll');\n if (sinceToken) {\n query.since = sinceToken;\n }\n return this.ajax(url, 'GET', {\n data: query\n });\n }\n\n /**\n Called by the store in order to fetch a JSON array for\n the records that match a particular query.\n The `query` method makes an Ajax (HTTP GET) request to a URL\n computed by `buildURL`, and returns a promise for the resulting\n payload.\n The `query` argument is a simple JavaScript object that will be passed directly\n to the server as parameters.\n @method query\n @public\n @param {Store} store\n @param {Model} type\n @param {Object} query\n @param {AdapterPopulatedRecordArray} recordArray\n @param {Object} adapterOptions\n @return {Promise} promise\n */\n query(store, type, query) {\n let url = this.buildURL(type.modelName, null, null, 'query', query);\n if (this.sortQueryParams) {\n query = this.sortQueryParams(query);\n }\n return this.ajax(url, 'GET', {\n data: query\n });\n }\n\n /**\n Called by the store in order to fetch a JSON object for\n the record that matches a particular query.\n The `queryRecord` method makes an Ajax (HTTP GET) request to a URL\n computed by `buildURL`, and returns a promise for the resulting\n payload.\n The `query` argument is a simple JavaScript object that will be passed directly\n to the server as parameters.\n @since 1.13.0\n @method queryRecord\n @public\n @param {Store} store\n @param {Model} type\n @param {Object} query\n @param {Object} adapterOptions\n @return {Promise} promise\n */\n queryRecord(store, type, query, adapterOptions) {\n let url = this.buildURL(type.modelName, null, null, 'queryRecord', query);\n if (this.sortQueryParams) {\n query = this.sortQueryParams(query);\n }\n return this.ajax(url, 'GET', {\n data: query\n });\n }\n\n /**\n Called by the store in order to fetch several records together if `coalesceFindRequests` is true\n For example, if the original payload looks like:\n ```js\n {\n \"id\": 1,\n \"title\": \"Rails is omakase\",\n \"comments\": [ 1, 2, 3 ]\n }\n ```\n The IDs will be passed as a URL-encoded Array of IDs, in this form:\n ```\n ids[]=1&ids[]=2&ids[]=3\n ```\n Many servers, such as Rails and PHP, will automatically convert this URL-encoded array\n into an Array for you on the server-side. If you want to encode the\n IDs, differently, just override this (one-line) method.\n The `findMany` method makes an Ajax (HTTP GET) request to a URL computed by `buildURL`, and returns a\n promise for the resulting payload.\n @method findMany\n @public\n @param {Store} store\n @param {Model} type\n @param {Array} ids\n @param {Array} snapshots\n @return {Promise} promise\n */\n findMany(store, type, ids, snapshots) {\n let url = this.buildURL(type.modelName, ids, snapshots, 'findMany');\n return this.ajax(url, 'GET', {\n data: {\n ids: ids\n }\n });\n }\n\n /**\n Called by the store in order to fetch a JSON array for\n the unloaded records in a has-many relationship that were originally\n specified as a URL (inside of `links`).\n For example, if your original payload looks like this:\n ```js\n {\n \"post\": {\n \"id\": 1,\n \"title\": \"Rails is omakase\",\n \"links\": { \"comments\": \"/posts/1/comments\" }\n }\n }\n ```\n This method will be called with the parent record and `/posts/1/comments`.\n The `findHasMany` method will make an Ajax (HTTP GET) request to the originally specified URL.\n The format of your `links` value will influence the final request URL via the `urlPrefix` method:\n * Links beginning with `//`, `http://`, `https://`, will be used as is, with no further manipulation.\n * Links beginning with a single `/` will have the current adapter's `host` value prepended to it.\n * Links with no beginning `/` will have a parentURL prepended to it, via the current adapter's `buildURL`.\n @method findHasMany\n @public\n @param {Store} store\n @param {Snapshot} snapshot\n @param {String} url\n @param {Object} relationship meta object describing the relationship\n @return {Promise} promise\n */\n findHasMany(store, snapshot, url, relationship) {\n let id = snapshot.id;\n let type = snapshot.modelName;\n (true && !(typeof id === 'string' && id.length > 0) && (0, _debug.assert)(`Attempted to fetch the hasMany relationship for ${type}, but the record has no id`, typeof id === 'string' && id.length > 0));\n url = this.urlPrefix(url, this.buildURL(type, id, snapshot, 'findHasMany'));\n return this.ajax(url, 'GET');\n }\n\n /**\n Called by the store in order to fetch the JSON for the unloaded record in a\n belongs-to relationship that was originally specified as a URL (inside of\n `links`).\n For example, if your original payload looks like this:\n ```js\n {\n \"person\": {\n \"id\": 1,\n \"name\": \"Tom Dale\",\n \"links\": { \"group\": \"/people/1/group\" }\n }\n }\n ```\n This method will be called with the parent record and `/people/1/group`.\n The `findBelongsTo` method will make an Ajax (HTTP GET) request to the originally specified URL.\n The format of your `links` value will influence the final request URL via the `urlPrefix` method:\n * Links beginning with `//`, `http://`, `https://`, will be used as is, with no further manipulation.\n * Links beginning with a single `/` will have the current adapter's `host` value prepended to it.\n * Links with no beginning `/` will have a parentURL prepended to it, via the current adapter's `buildURL`.\n @method findBelongsTo\n @public\n @param {Store} store\n @param {Snapshot} snapshot\n @param {String} url\n @param {Object} relationship meta object describing the relationship\n @return {Promise} promise\n */\n findBelongsTo(store, snapshot, url, relationship) {\n let id = snapshot.id;\n let type = snapshot.modelName;\n (true && !(typeof id === 'string' && id.length > 0) && (0, _debug.assert)(`Attempted to fetch the belongsTo relationship for ${type}, but the record has no id`, typeof id === 'string' && id.length > 0));\n url = this.urlPrefix(url, this.buildURL(type, id, snapshot, 'findBelongsTo'));\n return this.ajax(url, 'GET');\n }\n\n /**\n Called by the store when a newly created record is\n saved via the `save` method on a model record instance.\n The `createRecord` method serializes the record and makes an Ajax (HTTP POST) request\n to a URL computed by `buildURL`.\n See `serialize` for information on how to customize the serialized form\n of a record.\n @method createRecord\n @public\n @param {Store} store\n @param {Model} type\n @param {Snapshot} snapshot\n @return {Promise} promise\n */\n createRecord(store, type, snapshot) {\n let url = this.buildURL(type.modelName, null, snapshot, 'createRecord');\n const data = (0, _private.serializeIntoHash)(store, type, snapshot);\n return this.ajax(url, 'POST', {\n data\n });\n }\n\n /**\n Called by the store when an existing record is saved\n via the `save` method on a model record instance.\n The `updateRecord` method serializes the record and makes an Ajax (HTTP PUT) request\n to a URL computed by `buildURL`.\n See `serialize` for information on how to customize the serialized form\n of a record.\n @method updateRecord\n @public\n @param {Store} store\n @param {Model} schema\n @param {Snapshot} snapshot\n @return {Promise} promise\n */\n updateRecord(store, schema, snapshot) {\n const data = (0, _private.serializeIntoHash)(store, schema, snapshot, {});\n const type = snapshot.modelName;\n const id = snapshot.id;\n (true && !(typeof id === 'string' && id.length > 0) && (0, _debug.assert)(`Attempted to update the ${type} record, but the record has no id`, typeof id === 'string' && id.length > 0));\n let url = this.buildURL(type, id, snapshot, 'updateRecord');\n return this.ajax(url, 'PUT', {\n data\n });\n }\n\n /**\n Called by the store when a record is deleted.\n The `deleteRecord` method makes an Ajax (HTTP DELETE) request to a URL computed by `buildURL`.\n @method deleteRecord\n @public\n @param {Store} store\n @param {Model} type\n @param {Snapshot} snapshot\n @return {Promise} promise\n */\n deleteRecord(store, schema, snapshot) {\n const type = snapshot.modelName;\n const id = snapshot.id;\n (true && !(typeof id === 'string' && id.length > 0) && (0, _debug.assert)(`Attempted to delete the ${type} record, but the record has no id`, typeof id === 'string' && id.length > 0));\n return this.ajax(this.buildURL(type, id, snapshot, 'deleteRecord'), 'DELETE');\n }\n _stripIDFromURL(store, snapshot) {\n const type = snapshot.modelName;\n const id = snapshot.id;\n (true && !(typeof id === 'string' && id.length > 0) && (0, _debug.assert)(`Attempted to strip the url from the ${type} record for coalescing, but the record has no id`, typeof id === 'string' && id.length > 0));\n let url = this.buildURL(type, id, snapshot);\n let expandedURL = url.split('/');\n // Case when the url is of the format ...something/:id\n // We are decodeURIComponent-ing the lastSegment because if it represents\n // the id, it has been encodeURIComponent-ified within `buildURL`. If we\n // don't do this, then records with id having special characters are not\n // coalesced correctly (see GH #4190 for the reported bug)\n let lastSegment = expandedURL[expandedURL.length - 1];\n if (decodeURIComponent(lastSegment) === id) {\n expandedURL[expandedURL.length - 1] = '';\n } else if (id && endsWith(lastSegment, '?id=' + id)) {\n //Case when the url is of the format ...something?id=:id\n expandedURL[expandedURL.length - 1] = lastSegment.substring(0, lastSegment.length - id.length - 1);\n }\n return expandedURL.join('/');\n }\n /**\n Organize records into groups, each of which is to be passed to separate\n calls to `findMany`.\n This implementation groups together records that have the same base URL but\n differing ids. For example `/comments/1` and `/comments/2` will be grouped together\n because we know findMany can coalesce them together as `/comments?ids[]=1&ids[]=2`\n It also supports urls where ids are passed as a query param, such as `/comments?id=1`\n but not those where there is more than 1 query param such as `/comments?id=2&name=David`\n Currently only the query param of `id` is supported. If you need to support others, please\n override this or the `_stripIDFromURL` method.\n It does not group records that have differing base urls, such as for example: `/posts/1/comments/2`\n and `/posts/2/comments/3`\n @method groupRecordsForFindMany\n @public\n @param {Store} store\n @param {Array} snapshots\n @return {Array} an array of arrays of records, each of which is to be\n loaded separately by `findMany`.\n */\n groupRecordsForFindMany(store, snapshots) {\n let groups = new Map();\n let adapter = this;\n let maxURLLength = this.maxURLLength;\n snapshots.forEach(snapshot => {\n let baseUrl = adapter._stripIDFromURL(store, snapshot);\n if (!groups.has(baseUrl)) {\n groups.set(baseUrl, []);\n }\n groups.get(baseUrl).push(snapshot);\n });\n function splitGroupToFitInUrl(group, maxURLLength, paramNameLength) {\n let idsSize = 0;\n let baseUrl = adapter._stripIDFromURL(store, group[0]);\n let splitGroups = [[]];\n group.forEach(snapshot => {\n let additionalLength = encodeURIComponent(snapshot.id).length + paramNameLength;\n if (baseUrl.length + idsSize + additionalLength >= maxURLLength) {\n idsSize = 0;\n splitGroups.push([]);\n }\n idsSize += additionalLength;\n let lastGroupIndex = splitGroups.length - 1;\n splitGroups[lastGroupIndex].push(snapshot);\n });\n return splitGroups;\n }\n let groupsArray = [];\n groups.forEach((group, key) => {\n let paramNameLength = '&ids%5B%5D='.length;\n let splitGroups = splitGroupToFitInUrl(group, maxURLLength, paramNameLength);\n splitGroups.forEach(splitGroup => groupsArray.push(splitGroup));\n });\n return groupsArray;\n }\n\n /**\n Takes an ajax response, and returns the json payload or an error.\n By default this hook just returns the json payload passed to it.\n You might want to override it in two cases:\n 1. Your API might return useful results in the response headers.\n Response headers are passed in as the second argument.\n 2. Your API might return errors as successful responses with status code\n 200 and an Errors text or object. You can return a `InvalidError` or a\n `AdapterError` (or a sub class) from this hook and it will automatically\n reject the promise and put your record into the invalid or error state.\n Returning a `InvalidError` from this method will cause the\n record to transition into the `invalid` state and make the\n `errors` object available on the record. When returning an\n `InvalidError` the store will attempt to normalize the error data\n returned from the server using the serializer's `extractErrors`\n method.\n @since 1.13.0\n @method handleResponse\n @public\n @param {Number} status\n @param {Object} headers\n @param {Object} payload\n @param {Object} requestData - the original request information\n @return {Object | AdapterError} response\n */\n handleResponse(status, headers, payload, requestData) {\n if (this.isSuccess(status, headers, payload)) {\n return payload;\n } else if (this.isInvalid(status, headers, payload)) {\n return new _error.InvalidError(typeof payload === 'object' && 'errors' in payload ? payload.errors : undefined);\n }\n let errors = this.normalizeErrorResponse(status, headers, payload);\n let detailedMessage = this.generatedDetailedMessage(status, headers, payload, requestData);\n switch (status) {\n case 401:\n return new _error.UnauthorizedError(errors, detailedMessage);\n case 403:\n return new _error.ForbiddenError(errors, detailedMessage);\n case 404:\n return new _error.NotFoundError(errors, detailedMessage);\n case 409:\n return new _error.ConflictError(errors, detailedMessage);\n default:\n if (status >= 500) {\n return new _error.ServerError(errors, detailedMessage);\n }\n }\n return new _error.default(errors, detailedMessage);\n }\n\n /**\n Default `handleResponse` implementation uses this hook to decide if the\n response is a success.\n @since 1.13.0\n @method isSuccess\n @public\n @param {Number} status\n @param {Object} headers\n @param {Object} payload\n @return {Boolean}\n */\n isSuccess(status, _headers, _payload) {\n return status >= 200 && status < 300 || status === 304;\n }\n\n /**\n Default `handleResponse` implementation uses this hook to decide if the\n response is an invalid error.\n @since 1.13.0\n @method isInvalid\n @public\n @param {Number} status\n @param {Object} headers\n @param {Object} payload\n @return {Boolean}\n */\n isInvalid(status, _headers, _payload) {\n return status === 422;\n }\n\n /**\n Takes a URL, an HTTP method and a hash of data, and makes an\n HTTP request.\n When the server responds with a payload, Ember Data will call into `extractSingle`\n or `extractArray` (depending on whether the original query was for one record or\n many records).\n By default, `ajax` method has the following behavior:\n * It sets the response `dataType` to `\"json\"`\n * If the HTTP method is not `\"GET\"`, it sets the `Content-Type` to be\n `application/json; charset=utf-8`\n * If the HTTP method is not `\"GET\"`, it stringifies the data passed in. The\n data is the serialized record in the case of a save.\n * Registers success and failure handlers.\n @method ajax\n @private\n @param {String} url\n @param {String} type The request type GET, POST, PUT, DELETE etc.\n @param {Object} options\n @return {Promise} promise\n */\n async ajax(url, type, options = {}) {\n let adapter = this;\n let requestData = {\n url: url,\n method: type\n };\n if (this.useFetch) {\n let hash = adapter.ajaxOptions(url, type, options);\n let response = await this._fetchRequest(hash);\n let payload = await (0, _private.determineBodyPromise)(response, requestData);\n if (response.ok && !(payload instanceof Error)) {\n return fetchSuccessHandler(adapter, payload, response, requestData);\n } else {\n throw fetchErrorHandler(adapter, payload, response, null, requestData);\n }\n } else {\n let hash = adapter.ajaxOptions(url, type, options);\n return new _rsvp.Promise(function (resolve, reject) {\n hash.success = function (payload, textStatus, jqXHR) {\n let response = ajaxSuccessHandler(adapter, payload, jqXHR, requestData);\n (0, _runloop.join)(null, resolve, response);\n };\n hash.error = function (jqXHR, textStatus, errorThrown) {\n let error = ajaxErrorHandler(adapter, jqXHR, errorThrown, requestData);\n (0, _runloop.join)(null, reject, error);\n };\n adapter._ajax(hash);\n }, 'DS: RESTAdapter#ajax ' + type + ' to ' + url);\n }\n }\n\n /**\n @method _ajaxRequest\n @private\n @param {Object} options jQuery ajax options to be used for the ajax request\n */\n _ajaxRequest(options) {\n // TODO add assertion that jquery is there rather then equality check\n typeof jQuery !== 'undefined' && jQuery.ajax(options);\n }\n _fetchRequest(options) {\n let fetchFunction = (0, _private.fetch)();\n if (fetchFunction) {\n return fetchFunction(options.url, options);\n } else {\n throw new Error('cannot find the `fetch` module or the `fetch` global. Did you mean to install the `ember-fetch` addon?');\n }\n }\n _ajax(options) {\n if (this.useFetch) {\n this._fetchRequest(options);\n } else {\n this._ajaxRequest(options);\n }\n }\n\n /**\n @method ajaxOptions\n @private\n @param {String} url\n @param {String} type The request type GET, POST, PUT, DELETE etc.\n @param {Object} options\n @return {Object}\n */\n ajaxOptions(url, method, options) {\n let reqOptions = Object.assign({\n url,\n method,\n type: method\n }, options);\n if (this.headers !== undefined) {\n reqOptions.headers = {\n ...this.headers,\n ...reqOptions.headers\n };\n } else if (!options.headers) {\n reqOptions.headers = {};\n }\n let contentType = reqOptions.contentType || this._defaultContentType;\n if (this.useFetch) {\n if (reqOptions.data && reqOptions.type !== 'GET' && reqOptions.headers) {\n if (!reqOptions.headers['Content-Type'] && !reqOptions.headers['content-type']) {\n reqOptions.headers['content-type'] = contentType;\n }\n }\n reqOptions = fetchOptions(reqOptions, this);\n } else {\n // GET requests without a body should not have a content-type header\n // and may be unexpected by a server\n if (reqOptions.data && reqOptions.type !== 'GET') {\n reqOptions = {\n ...reqOptions,\n contentType\n };\n }\n reqOptions = ajaxOptions(reqOptions, this);\n }\n reqOptions.url = this._ajaxURL(reqOptions.url);\n return reqOptions;\n }\n _ajaxURL(url) {\n if (this.fastboot?.isFastBoot) {\n let httpRegex = /^https?:\\/\\//;\n let protocolRelativeRegex = /^\\/\\//;\n let protocol = this.fastboot.request.protocol;\n let host = this.fastboot.request.host;\n if (protocolRelativeRegex.test(url)) {\n return `${protocol}${url}`;\n } else if (!httpRegex.test(url)) {\n try {\n return `${protocol}//${host}${url}`;\n } catch (fbError) {\n throw new Error('You are using Ember Data with no host defined in your adapter. This will attempt to use the host of the FastBoot request, which is not configured for the current host of this request. Please set the hostWhitelist property for in your environment.js. FastBoot Error: ' + fbError.message);\n }\n }\n }\n return url;\n }\n\n /**\n @method parseErrorResponse\n @private\n @param {String} responseText\n @return {Object}\n */\n parseErrorResponse(responseText) {\n let json = responseText;\n try {\n json = JSON.parse(responseText);\n } catch (e) {\n // ignored\n }\n return json;\n }\n\n /**\n @method normalizeErrorResponse\n @private\n @param {Number} status\n @param {Object} headers\n @param {Object} payload\n @return {Array} errors payload\n */\n normalizeErrorResponse(status, _headers, payload) {\n if (payload && typeof payload === 'object' && 'errors' in payload && Array.isArray(payload.errors)) {\n return payload.errors;\n } else {\n return [{\n status: `${status}`,\n // Set to a string per the JSON API spec: https://jsonapi.org/format/#errors\n title: 'The backend responded with an error',\n detail: `${payload}`\n }];\n }\n }\n\n /**\n Generates a detailed (\"friendly\") error message, with plenty\n of information for debugging (good luck!)\n @method generatedDetailedMessage\n @private\n @param {Number} status\n @param {Object} headers\n @param {Object} payload\n @param {Object} requestData\n @return {String} detailed error message\n */\n generatedDetailedMessage(status, headers, payload, requestData) {\n let shortenedPayload;\n let payloadContentType = headers['content-type'] || 'Empty Content-Type';\n if (payloadContentType === 'text/html' && typeof payload === 'string' && payload.length > 250) {\n shortenedPayload = '[Omitted Lengthy HTML]';\n } else {\n shortenedPayload = payload;\n }\n let requestDescription = requestData.method + ' ' + requestData.url;\n let payloadDescription = 'Payload (' + payloadContentType + ')';\n return ['Ember Data Request ' + requestDescription + ' returned a ' + status, payloadDescription, shortenedPayload].join('\\n');\n }\n\n /**\n Used by `findAll` and `findRecord` to build the query's `data` hash\n supplied to the ajax method.\n @method buildQuery\n @since 2.5.0\n @public\n @param {Snapshot} snapshot\n @return {Object}\n */\n buildQuery(snapshot) {\n let query = {};\n if (snapshot) {\n let {\n include\n } = snapshot;\n if (include) {\n query.include = include;\n }\n }\n return query;\n }\n }, _applyDecoratedDescriptor(_class.prototype, \"fastboot\", [_dec], Object.getOwnPropertyDescriptor(_class.prototype, \"fastboot\"), _class.prototype), _class);\n function ajaxSuccess(adapter, payload, requestData, responseData) {\n let response;\n try {\n response = adapter.handleResponse(responseData.status, responseData.headers, payload, requestData);\n } catch (error) {\n return _rsvp.Promise.reject(error);\n }\n if (response && response.isAdapterError) {\n return _rsvp.Promise.reject(response);\n } else {\n return response;\n }\n }\n function ajaxError(adapter, payload, requestData, responseData) {\n let error;\n if (responseData.errorThrown instanceof Error && payload !== '') {\n error = responseData.errorThrown;\n } else if (responseData.textStatus === 'timeout') {\n error = new _error.TimeoutError();\n } else if (responseData.textStatus === 'abort' || responseData.status === 0) {\n error = handleAbort(requestData, responseData);\n } else {\n try {\n error = adapter.handleResponse(responseData.status, responseData.headers, payload || responseData.errorThrown, requestData);\n } catch (e) {\n error = e;\n }\n }\n return error;\n }\n\n // Adapter abort error to include any relevent info, e.g. request/response:\n function handleAbort(requestData, responseData) {\n let {\n method,\n url,\n errorThrown\n } = requestData;\n let {\n status\n } = responseData;\n let msg = `Request failed: ${method} ${url} ${errorThrown || ''}`;\n let errors = [{\n title: 'Adapter Error',\n detail: msg.trim(),\n status\n }];\n return new _error.AbortError(errors);\n }\n\n //From http://stackoverflow.com/questions/280634/endswith-in-javascript\n function endsWith(string, suffix) {\n if (typeof String.prototype.endsWith !== 'function') {\n return string.indexOf(suffix, string.length - suffix.length) !== -1;\n } else {\n return string.endsWith(suffix);\n }\n }\n function fetchSuccessHandler(adapter, payload, response, requestData) {\n let responseData = fetchResponseData(response);\n return ajaxSuccess(adapter, payload, requestData, responseData);\n }\n function fetchErrorHandler(adapter, payload, response, errorThrown, requestData) {\n let responseData = fetchResponseData(response);\n if (responseData.status === 200 && payload instanceof Error) {\n responseData.errorThrown = payload;\n payload = responseData.errorThrown.payload;\n } else {\n responseData.errorThrown = errorThrown;\n if (typeof payload === 'string') {\n payload = adapter.parseErrorResponse(payload);\n }\n }\n return ajaxError(adapter, payload, requestData, responseData);\n }\n function ajaxSuccessHandler(adapter, payload, jqXHR, requestData) {\n let responseData = ajaxResponseData(jqXHR);\n return ajaxSuccess(adapter, payload, requestData, responseData);\n }\n function ajaxErrorHandler(adapter, jqXHR, errorThrown, requestData) {\n let responseData = ajaxResponseData(jqXHR);\n responseData.errorThrown = errorThrown;\n let payload = adapter.parseErrorResponse(jqXHR.responseText);\n if (true /* DEBUG */) {\n let message = `The server returned an empty string for ${requestData.method} ${requestData.url}, which cannot be parsed into a valid JSON. Return either null or {}.`;\n let validJSONString = !(responseData.textStatus === 'parsererror' && payload === '');\n (true && (0, _debug.warn)(message, validJSONString, {\n id: 'ds.adapter.returned-empty-string-as-JSON'\n }));\n }\n return ajaxError(adapter, payload, requestData, responseData);\n }\n function fetchResponseData(response) {\n return {\n status: response.status,\n textStatus: response.statusText,\n headers: headersToObject(response.headers)\n };\n }\n function ajaxResponseData(jqXHR) {\n return {\n status: jqXHR.status,\n textStatus: jqXHR.statusText,\n headers: (0, _private.parseResponseHeaders)(jqXHR.getAllResponseHeaders())\n };\n }\n function headersToObject(headers) {\n let headersObject = {};\n if (headers) {\n headers.forEach((value, key) => headersObject[key] = value);\n }\n return headersObject;\n }\n\n /**\n * Helper function that translates the options passed to `jQuery.ajax` into a format that `fetch` expects.\n *\n * @method fetchOptions\n * @for @ember-data/adapter/rest\n * @param {Object} _options\n * @param {Adapter} adapter\n * @private\n * @returns {Object}\n */\n function fetchOptions(options, adapter) {\n options.credentials = options.credentials || 'same-origin';\n if (options.data) {\n // GET and HEAD requests can't have a `body`\n if (options.method === 'GET' || options.method === 'HEAD') {\n // If no options are passed, Ember Data sets `data` to an empty object, which we test for.\n if (Object.keys(options.data).length && options.url) {\n // Test if there are already query params in the url (mimics jQuey.ajax).\n const queryParamDelimiter = options.url.indexOf('?') > -1 ? '&' : '?';\n options.url += `${queryParamDelimiter}${(0, _private.serializeQueryParams)(options.data)}`;\n }\n } else {\n // NOTE: a request's body cannot be an object, so we stringify it if it is.\n // JSON.stringify removes keys with values of `undefined` (mimics jQuery.ajax).\n // If the data is not a POJO (it's a String, FormData, etc), we just set it.\n // If the data is a string, we assume it's a stringified object.\n\n /* We check for Objects this way because we want the logic inside the consequent to run\n * if `options.data` is a POJO, not if it is a data structure whose `typeof` returns \"object\"\n * when it's not (Array, FormData, etc). The reason we don't use `options.data.constructor`\n * to check is in case `data` is an object with no prototype (e.g. created with null).\n */\n if (Object.prototype.toString.call(options.data) === '[object Object]') {\n options.body = JSON.stringify(options.data);\n } else {\n options.body = options.data;\n }\n }\n }\n return options;\n }\n function ajaxOptions(options, adapter) {\n options.dataType = 'json';\n options.context = adapter;\n if (options.data && options.type !== 'GET') {\n options.data = JSON.stringify(options.data);\n }\n options.beforeSend = function (xhr) {\n if (options.headers) {\n Object.keys(options.headers).forEach(key => {\n let headerValue = options.headers && options.headers[key];\n const isString = value => typeof value === 'string';\n if (isString(headerValue)) {\n xhr.setRequestHeader(key, headerValue);\n }\n });\n }\n };\n return options;\n }\n var _default = _exports.default = RESTAdapter;\n});","define(\"@ember-data/canary-features/default-features\", [\"exports\"], function (_exports) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.default = void 0;\n /**\n * ## Canary Features\n *\n * EmberData allows users to test features that are implemented but not yet\n * available even in canary.\n *\n * Typically these features represent work that might introduce a new concept,\n * new API, change an API, or risk an unintended change in behavior to consuming\n * applications.\n *\n * Such features have their implementations guarded by a \"feature flag\", and the\n * flag is only activated once the core-data team is prepared to ship the work\n * in a canary release.\n *\n * ### Installing Canary\n *\n * To test a feature you MUST be using a canary build. Canary builds are published\n * to `npm` and can be installed using a precise tag (such as `ember-data@3.16.0-alpha.1`)\n * or by installing the latest dist-tag published to the `canary` channel.\n *\n * *Using `npm` to install the latest canary*\n *\n * ```cli\n * npm install --save-dev ember-data@canary\n * ```\n *\n * *Using `yarn` to install the latest canary*\n *\n * ```cli\n * yarn add ember-data@canary\n * ```\n *\n * ### Activating a Canary Feature\n *\n * Once you have installed canary, feature-flags can be activated at build-time by an environment\n * variable or at runtime using `window.EmberDataENV`.\n *\n * The \"off\" branch of feature-flagged code is always stripped from production builds, so you\n * MUST use the build-time environment variable to activate a flag if testing production.\n *\n * The list of available feature-flags is located [here](https://github.com/emberjs/data/tree/master/packages/canary-features/addon/default-features.ts \"List of EmberData FeatureFlags\")\n *\n * #### Runtime Configuration\n *\n * To configure feature-flags at runtime you will want to configure `window.EmberDataENV = {}` appropriately.\n * You should add this global property in your app prior to your application booting. At the top of\n * your `app.js` file is a convenient location, as is within ` index.html` as a script running prior\n * to loading any other scripts.\n *\n * *Example activating a single feature flags*\n *\n * ```js\n * window.EmberDataENV = {\n * FEATURES: {\n * RECORD_DATA_ERRORS: true,\n * }\n * }\n * ```\n *\n * *Example activating multiple feature flags*\n *\n * ```js\n * window.EmberDataENV = {\n * FEATURES: {\n * RECORD_DATA_ERRORS: true,\n * RECORD_DATA_STATE: true,\n * }\n * }\n * ```\n *\n * *Example activating all feature flags*\n *\n * ```js\n * window.EmberDataENV = {\n * ENABLE_OPTIONAL_FEATURES: true\n * }\n * ```\n *\n * #### Build Time Configuration\n *\n * *Example activating a single feature flags*\n *\n * ```js\n * EMBER_DATA_FEATURE_OVERRIDE=SAMPLE_FEATURE_FLAG ember build\n * ```\n *\n * *Example activating multiple feature flags*\n *\n * ```js\n * EMBER_DATA_FEATURE_OVERRIDE=SAMPLE_FEATURE_FLAG,CUSTOM_MODEL_CLASS ember build\n * ```\n *\n * *Example activating all feature flags*\n *\n * ```js\n * EMBER_DATA_FEATURE_OVERRIDE=ENABLE_ALL_OPTIONAL ember build\n * ```\n *\n * ### Preparing an Addon to use a Canary Feature\n *\n * For most addons and most features simple version detection should be\n * enough. Using the provided version compatibility helpers from\n * [ember-compatibility-helpers](https://github.com/pzuraq/ember-compatibility-helpers)\n * the following can be done:\n *\n * ```js\n * if (gte('@ember-data/store', '3.12.0')) {\n *\n * } else {\n *\n * }\n * ```\n *\n * For addons needing more advanced detection [babel-plugin-debug-macros](https://github.com/ember-cli/babel-plugin-debug-macros)\n * can be leveraged to provide code-stripping based on feature presence. For example in your addon's `index.js`:\n *\n * ```js\n * function debugMacros(features) {\n * let plugins = [\n * [\n * require.resolve('babel-plugin-debug-macros'),\n * {\n * flags: [\n * {\n * source: '/feature-flags',\n * flags: features,\n * },\n * ],\n * },\n * '/canary-features-stripping',\n * ],\n * ];\n *\n * return plugins;\n * }\n *\n * module.exports = {\n * name: '',\n *\n * init() {\n * this._super.init.apply(this, arguments);\n *\n * let features;\n * try {\n * features = this.project.require('@ember-data/private-build-infra/src/features')();\n * } catch (e) {\n * features = { CUSTOM_MODEL_CLASS: false };\n * }\n *\n * this.options = this.options || {};\n * this.options.babel = this.options.babel || {};\n * // this ensures that the same `@ember-data/canary-features` processing that the various\n * // ember-data addons do is done for this addon\n * this.options.babel.plugins = [...debugMacros(features)];\n * }\n * }\n * ```\n *\n @module @ember-data/canary-features\n @main @ember-data/canary-features\n */\n /*\n This list of features is used both at build time (by `@ember-data/private-build-infra`)\n and at runtime (by `@ember-data/canary-features`).\n \n The valid values are:\n \n - true - The feature is enabled at all times, and cannot be disabled.\n - false - The feature is disabled at all times, and cannot be enabled.\n - null - The feature is disabled by default, but can be enabled at runtime via `EmberDataENV`.\n */\n var _default = _exports.default = {\n SAMPLE_FEATURE_FLAG: null,\n RECORD_DATA_ERRORS: true,\n RECORD_DATA_STATE: true,\n REQUEST_SERVICE: true,\n CUSTOM_MODEL_CLASS: true,\n REMOVE_RECORD_ARRAY_MANAGER_LEGACY_COMPAT: true\n };\n});","define(\"@ember-data/canary-features/index\", [\"exports\", \"@ember-data/canary-features/default-features\"], function (_exports, _defaultFeatures) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.SAMPLE_FEATURE_FLAG = _exports.REQUEST_SERVICE = _exports.REMOVE_RECORD_ARRAY_MANAGER_LEGACY_COMPAT = _exports.RECORD_DATA_STATE = _exports.RECORD_DATA_ERRORS = _exports.FEATURES = _exports.CUSTOM_MODEL_CLASS = void 0;\n /* globals EmberDataENV */\n\n const ENV = typeof EmberDataENV !== 'undefined' && EmberDataENV !== null ? EmberDataENV : {};\n function featureValue(value) {\n if (ENV.ENABLE_OPTIONAL_FEATURES && value === null) {\n return true;\n }\n return value;\n }\n const FEATURES = _exports.FEATURES = Object.assign({}, _defaultFeatures.default, ENV.FEATURES);\n const SAMPLE_FEATURE_FLAG = _exports.SAMPLE_FEATURE_FLAG = featureValue(FEATURES.SAMPLE_FEATURE_FLAG);\n const RECORD_DATA_ERRORS = _exports.RECORD_DATA_ERRORS = featureValue(FEATURES.RECORD_DATA_ERRORS);\n const RECORD_DATA_STATE = _exports.RECORD_DATA_STATE = featureValue(FEATURES.RECORD_DATA_STATE);\n const REQUEST_SERVICE = _exports.REQUEST_SERVICE = featureValue(FEATURES.REQUEST_SERVICE);\n const CUSTOM_MODEL_CLASS = _exports.CUSTOM_MODEL_CLASS = featureValue(FEATURES.CUSTOM_MODEL_CLASS);\n const REMOVE_RECORD_ARRAY_MANAGER_LEGACY_COMPAT = _exports.REMOVE_RECORD_ARRAY_MANAGER_LEGACY_COMPAT = featureValue(FEATURES.REMOVE_RECORD_ARRAY_MANAGER_LEGACY_COMPAT);\n});","define(\"@ember-data/debug/index\", [\"exports\", \"@ember/array\", \"@ember/debug\", \"@ember/debug/data-adapter\", \"@ember/object\", \"@ember/object/observers\", \"@ember/service\", \"@ember/string\", \"@ember-data/debug/setup\"], function (_exports, _array, _debug, _dataAdapter, _object, _observers, _service, _string, _setup) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.default = void 0;\n 0; //eaimeta@70e063a35619d71f0,\"@ember/array\",0,\"@ember/debug\",0,\"@ember/debug/data-adapter\",0,\"@ember/object\",0,\"@ember/object/observers\",0,\"@ember/service\",0,\"@ember/string\",0,\"@ember-data/debug/setup\"eaimeta@70e063a35619d71f\n /**\n # Overview\n \n This package provides the `DataAdapter` which the [Ember Inspector](https://github.com/emberjs/ember-inspector)\n uses to subscribe and retrieve information for the `data` tab in the inspector.\n \n This package adds roughly .6 KB when minified and compressed to your application in production; however,\n you can opt out of shipping this addon in production via options in `ember-cli-build.js`\n \n ```js\n let app = new EmberApp(defaults, {\n emberData: {\n includeDataAdapterInProduction: false\n }\n });\n ```\n \n When using `ember-data` as a dependency of your app, the default is to ship the inspector support to production.\n \n When not using `ember-data` as a dependency but instead using EmberData via declaring specific `@ember-data/`\n dependencies the default is to not ship to production.\n \n @module @ember-data/debug\n @main @ember-data/debug\n */\n /**\n Implements `@ember/debug/data-adapter` with for EmberData\n integration with the ember-inspector.\n \n @class InspectorDataAdapter\n @extends DataAdapter\n @private\n */\n var _default = _exports.default = _dataAdapter.default.extend({\n store: (0, _service.inject)('store'),\n /**\n Specifies how records can be filtered based on the state of the record\n Records returned will need to have a `filterValues`\n property with a key for every name in the returned array\n @method getFilters\n @private\n @return {Array} List of objects defining filters\n The object should have a `name` and `desc` property\n */\n getFilters() {\n return [{\n name: 'isNew',\n desc: 'New'\n }, {\n name: 'isModified',\n desc: 'Modified'\n }, {\n name: 'isClean',\n desc: 'Clean'\n }];\n },\n _nameToClass(type) {\n return (0, _object.get)(this, 'store').modelFor(type);\n },\n /**\n Fetch the model types and observe them for changes.\n Maintains the list of model types without needing the Model package for detection.\n @method watchModelTypes\n @private\n @param {Function} typesAdded Callback to call to add types.\n Takes an array of objects containing wrapped types (returned from `wrapModelType`).\n @param {Function} typesUpdated Callback to call when a type has changed.\n Takes an array of objects containing wrapped types.\n @return {Function} Method to call to remove all observers\n */\n watchModelTypes(typesAdded, typesUpdated) {\n const store = (0, _object.get)(this, 'store');\n const __createRecordData = store._createRecordData;\n const _releaseMethods = [];\n const discoveredTypes = (0, _setup.typesMapFor)(store);\n\n // Add any models that were added during initialization of the app, before the inspector was opened\n discoveredTypes.forEach((_, type) => {\n this.watchTypeIfUnseen(store, discoveredTypes, type, typesAdded, typesUpdated, _releaseMethods);\n });\n\n // Overwrite _createRecordData so newly added models will get added to the list\n store._createRecordData = identifier => {\n this.watchTypeIfUnseen(store, discoveredTypes, identifier.type, typesAdded, typesUpdated, _releaseMethods);\n return __createRecordData.call(store, identifier);\n };\n let release = () => {\n _releaseMethods.forEach(fn => fn());\n store._createRecordData = __createRecordData;\n // reset the list so the models can be added if the inspector is re-opened\n // the entries are set to false instead of removed, since the models still exist in the app\n // we just need the inspector to become aware of them\n discoveredTypes.forEach((value, key) => {\n discoveredTypes.set(key, false);\n });\n this.releaseMethods.removeObject(release);\n };\n this.releaseMethods.pushObject(release);\n return release;\n },\n /**\n * Loop over the discovered types and use the callbacks from watchModelTypes to notify\n * the consumer of this adapter about the mdoels.\n *\n * @method watchTypeIfUnseen\n * @param {store} store\n * @param {Map} discoveredTypes\n * @param {String} type\n * @param {Function} typesAdded\n * @param {Function} typesUpdated\n * @param {Array} releaseMethods\n * @private\n */\n watchTypeIfUnseen(store, discoveredTypes, type, typesAdded, typesUpdated, releaseMethods) {\n if (discoveredTypes.get(type) !== true) {\n let klass = store.modelFor(type);\n let wrapped = this.wrapModelType(klass, type);\n releaseMethods.push(this.observeModelType(type, typesUpdated));\n typesAdded([wrapped]);\n discoveredTypes.set(type, true);\n }\n },\n /**\n Creates a human readable string used for column headers\n @method columnNameToDesc\n @private\n @param {String} name The attribute name\n @return {String} Human readable string based on the attribute name\n */\n columnNameToDesc(name) {\n return (0, _string.capitalize)((0, _string.underscore)(name).replace(/_/g, ' ').trim());\n },\n /**\n Get the columns for a given model type\n @method columnsForType\n @private\n @param {Model} typeClass\n @return {Array} An array of columns of the following format:\n name: {String} The name of the column\n desc: {String} Humanized description (what would show in a table column name)\n */\n columnsForType(typeClass) {\n let columns = [{\n name: 'id',\n desc: 'Id'\n }];\n let count = 0;\n let self = this;\n (0, _object.get)(typeClass, 'attributes').forEach((meta, name) => {\n if (count++ > self.attributeLimit) {\n return false;\n }\n let desc = this.columnNameToDesc(name);\n columns.push({\n name: name,\n desc: desc\n });\n });\n return columns;\n },\n /**\n Fetches all loaded records for a given type\n @method getRecords\n @private\n @param {Model} modelClass of the record\n @param {String} modelName of the record\n @return {Array} An array of Model records\n This array will be observed for changes,\n so it should update when new records are added/removed\n */\n getRecords(modelClass, modelName) {\n if (arguments.length < 2) {\n // Legacy Ember.js < 1.13 support\n let containerKey = modelClass._debugContainerKey;\n if (containerKey) {\n let match = containerKey.match(/model:(.*)/);\n if (match !== null) {\n modelName = match[1];\n }\n }\n }\n (true && !(!!modelName) && (0, _debug.assert)('Cannot find model name. Please upgrade to Ember.js >= 1.13 for Ember Inspector support', !!modelName));\n return this.get('store').peekAll(modelName);\n },\n /**\n Gets the values for each column\n This is the attribute values for a given record\n @method getRecordColumnValues\n @private\n @param {Model} record to get values from\n @return {Object} Keys should match column names defined by the model type\n */\n getRecordColumnValues(record) {\n let count = 0;\n let columnValues = {\n id: (0, _object.get)(record, 'id')\n };\n record.eachAttribute(key => {\n if (count++ > this.attributeLimit) {\n return false;\n }\n columnValues[key] = (0, _object.get)(record, key);\n });\n return columnValues;\n },\n /**\n Returns keywords to match when searching records\n @method getRecordKeywords\n @private\n @param {Model} record\n @return {Array} Relevant keywords for search based on the record's attribute values\n */\n getRecordKeywords(record) {\n let keywords = [];\n let keys = (0, _array.A)(['id']);\n record.eachAttribute(key => keys.push(key));\n keys.forEach(key => keywords.push((0, _object.get)(record, key)));\n return keywords;\n },\n /**\n Returns the values of filters defined by `getFilters`\n These reflect the state of the record\n @method getRecordFilterValues\n @private\n @param {Model} record\n @return {Object} The record state filter values\n */\n getRecordFilterValues(record) {\n return {\n isNew: record.get('isNew'),\n isModified: record.get('hasDirtyAttributes') && !record.get('isNew'),\n isClean: !record.get('hasDirtyAttributes')\n };\n },\n /**\n Returns a color that represents the record's state\n Possible colors: black, blue, green\n @method getRecordColor\n @private\n @param {Model} record\n @return {String} The record color\n */\n getRecordColor(record) {\n let color = 'black';\n if (record.get('isNew')) {\n color = 'green';\n } else if (record.get('hasDirtyAttributes')) {\n color = 'blue';\n }\n return color;\n },\n /**\n Observes all relevant properties and re-sends the wrapped record\n when a change occurs\n @method observeRecord\n @private\n @param {Model} record\n @param {Function} recordUpdated Callback used to notify changes\n @return {Function} The function to call to remove all observers\n */\n observeRecord(record, recordUpdated) {\n let releaseMethods = (0, _array.A)();\n let keysToObserve = (0, _array.A)(['id', 'isNew', 'hasDirtyAttributes']);\n record.eachAttribute(key => keysToObserve.push(key));\n let adapter = this;\n keysToObserve.forEach(function (key) {\n let handler = function () {\n recordUpdated(adapter.wrapRecord(record));\n };\n (0, _observers.addObserver)(record, key, handler);\n releaseMethods.push(function () {\n (0, _observers.removeObserver)(record, key, handler);\n });\n });\n let release = function () {\n releaseMethods.forEach(fn => fn());\n };\n return release;\n }\n });\n});","define(\"@ember-data/debug/setup\", [\"exports\", \"@ember-data/store\"], function (_exports, _store) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.default = void 0;\n _exports.typesMapFor = typesMapFor;\n 0; //eaimeta@70e063a35619d71f0,\"@ember-data/store\"eaimeta@70e063a35619d71f\n const StoreTypesMap = new WeakMap();\n function typesMapFor(store) {\n let typesMap = StoreTypesMap.get(store);\n if (typesMap === undefined) {\n typesMap = new Map();\n StoreTypesMap.set(store, typesMap);\n }\n return typesMap;\n }\n\n // override _createRecordData to add the known models to the typesMap\n const __createRecordData = _store.default.prototype._createRecordData;\n _store.default.prototype._createRecordData = function (identifier) {\n const typesMap = typesMapFor(this);\n if (!typesMap.has(identifier.type)) {\n typesMap.set(identifier.type, false);\n }\n return __createRecordData.call(this, identifier);\n };\n var _default = _exports.default = {\n name: '@ember-data/data-adapter',\n initialize() {}\n };\n});","define('@ember-data/model/-private', ['exports', '@ember/debug', '@ember/object', '@ember-data/store/-private', '@ember/error', '@ember/object/compat', '@ember/runloop', '@ember/utils', '@glimmer/tracking', 'ember', '@ember/array', '@ember/array/proxy', '@ember/object/computed', 'ember-cached-decorator-polyfill', '@ember/object/internals', 'ember-inflector', '@ember/array/mutable', 'rsvp', '@ember/application'], (function (exports, debug, EmberObject, Private, EmberError, compat, runloop, utils, tracking, Ember, EmberArray, ArrayProxy, computed, emberCachedDecoratorPolyfill, internals, emberInflector, MutableArray, rsvp, application) { 'use strict';\n\n function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }\n\n var EmberObject__default = /*#__PURE__*/_interopDefaultLegacy(EmberObject);\n var EmberError__default = /*#__PURE__*/_interopDefaultLegacy(EmberError);\n var Ember__default = /*#__PURE__*/_interopDefaultLegacy(Ember);\n var EmberArray__default = /*#__PURE__*/_interopDefaultLegacy(EmberArray);\n var ArrayProxy__default = /*#__PURE__*/_interopDefaultLegacy(ArrayProxy);\n var MutableArray__default = /*#__PURE__*/_interopDefaultLegacy(MutableArray);\n\n function isElementDescriptor(args) {\n let [maybeTarget, maybeKey, maybeDesc] = args;\n return (\n // Ensure we have the right number of args\n args.length === 3 && (\n // Make sure the target is a class or object (prototype)\n typeof maybeTarget === 'function' || typeof maybeTarget === 'object' && maybeTarget !== null) &&\n // Make sure the key is a string\n typeof maybeKey === 'string' && (\n // Make sure the descriptor is the right shape\n typeof maybeDesc === 'object' && maybeDesc !== null && 'enumerable' in maybeDesc && 'configurable' in maybeDesc ||\n // TS compatibility\n maybeDesc === undefined)\n );\n }\n function computedMacroWithOptionalParams(fn) {\n {\n return (...maybeDesc) => isElementDescriptor(maybeDesc) ? fn()(...maybeDesc) : fn(...maybeDesc);\n }\n }\n\n /**\n @module @ember-data/model\n */\n\n function getDefaultValue(record, options, key) {\n if (typeof options.defaultValue === 'function') {\n return options.defaultValue.apply(null, arguments);\n } else {\n let defaultValue = options.defaultValue;\n (!(typeof defaultValue !== 'object' || defaultValue === null) && debug.assert(`Non primitive defaultValues are not supported because they are shared between all instances. If you would like to use a complex object as a default value please provide a function that returns the complex object.`, typeof defaultValue !== 'object' || defaultValue === null));\n return defaultValue;\n }\n }\n\n /**\n `attr` defines an attribute on a [Model](/ember-data/release/classes/Model).\n By default, attributes are passed through as-is, however you can specify an\n optional type to have the value automatically transformed.\n Ember Data ships with four basic transform types: `string`, `number`,\n `boolean` and `date`. You can define your own transforms by subclassing\n [Transform](/ember-data/release/classes/Transform).\n\n Note that you cannot use `attr` to define an attribute of `id`.\n\n `attr` takes an optional hash as a second parameter, currently\n supported options are:\n\n - `defaultValue`: Pass a string or a function to be called to set the attribute\n to a default value if and only if the key is absent from the payload response.\n\n Example\n\n ```app/models/user.js\n import Model, { attr } from '@ember-data/model';\n\n export default class UserModel extends Model {\n @attr('string') username;\n @attr('string') email;\n @attr('boolean', { defaultValue: false }) verified;\n }\n ```\n\n Default value can also be a function. This is useful it you want to return\n a new object for each attribute.\n\n ```app/models/user.js\n import Model, { attr } from '@ember-data/model';\n\n export default class UserModel extends Model {\n @attr('string') username;\n @attr('string') email;\n\n @attr({\n defaultValue() {\n return {};\n }\n })\n settings;\n }\n ```\n\n The `options` hash is passed as second argument to a transforms'\n `serialize` and `deserialize` method. This allows to configure a\n transformation and adapt the corresponding value, based on the config:\n\n ```app/models/post.js\n import Model, { attr } from '@ember-data/model';\n\n export default class PostModel extends Model {\n @attr('text', {\n uppercase: true\n })\n text;\n }\n ```\n\n ```app/transforms/text.js\n import Transform from '@ember-data/serializer/transform';\n\n export default class TextTransform extends Transform {\n serialize(value, options) {\n if (options.uppercase) {\n return value.toUpperCase();\n }\n\n return value;\n }\n\n deserialize(value) {\n return value;\n }\n }\n ```\n\n @method attr\n @public\n @static\n @for @ember-data/model\n @param {String|Object} type the attribute type\n @param {Object} options a hash of options\n @return {Attribute}\n */\n function attr(type, options) {\n if (typeof type === 'object') {\n options = type;\n type = undefined;\n } else {\n options = options || {};\n }\n let meta = {\n type: type,\n isAttribute: true,\n kind: 'attribute',\n options: options\n };\n return EmberObject.computed({\n get(key) {\n {\n if (['_internalModel', 'currentState'].indexOf(key) !== -1) {\n throw new Error(`'${key}' is a reserved property name on instances of classes extending Model. Please choose a different property name for your attr on ${this.constructor.toString()}`);\n }\n }\n let recordData = Private.recordDataFor(this);\n if (recordData.hasAttr(key)) {\n return recordData.getAttr(key);\n } else {\n return getDefaultValue(this, options, key);\n }\n },\n set(key, value) {\n {\n if (['_internalModel', 'currentState'].indexOf(key) !== -1) {\n throw new Error(`'${key}' is a reserved property name on instances of classes extending Model. Please choose a different property name for your attr on ${this.constructor.toString()}`);\n }\n }\n if (!this.isValid) {\n let oldValue = this._internalModel._recordData.getAttr(key);\n if (oldValue !== value) {\n const {\n errors\n } = this;\n if (errors.get(key)) {\n errors.remove(key);\n this.___recordState.cleanErrorRequests();\n }\n }\n }\n return this._internalModel.setDirtyAttribute(key, value);\n }\n }).meta(meta);\n }\n var attr$1 = computedMacroWithOptionalParams(attr);\n\n /**\n @module @ember-data/model\n */\n\n /**\n `belongsTo` is used to define One-To-One and One-To-Many\n relationships on a [Model](/ember-data/release/classes/Model).\n\n\n `belongsTo` takes an optional hash as a second parameter, currently\n supported options are:\n\n - `async`: A boolean value used to explicitly declare this to be an async relationship. The default is true.\n - `inverse`: A string used to identify the inverse property on a\n related model in a One-To-Many relationship. See [Explicit Inverses](#explicit-inverses)\n - `polymorphic` A boolean value to mark the relationship as polymorphic\n\n #### One-To-One\n To declare a one-to-one relationship between two models, use\n `belongsTo`:\n\n ```app/models/user.js\n import Model, { belongsTo } from '@ember-data/model';\n\n export default class UserModel extends Model {\n @belongsTo('profile') profile;\n }\n ```\n\n ```app/models/profile.js\n import Model, { belongsTo } from '@ember-data/model';\n\n export default class ProfileModel extends Model {\n @belongsTo('user') user;\n }\n ```\n\n #### One-To-Many\n To declare a one-to-many relationship between two models, use\n `belongsTo` in combination with `hasMany`, like this:\n\n ```app/models/post.js\n import Model, { hasMany } from '@ember-data/model';\n\n export default class PostModel extends Model {\n @hasMany('comment') comments;\n }\n ```\n\n ```app/models/comment.js\n import Model, { belongsTo } from '@ember-data/model';\n\n export default class CommentModel extends Model {\n @belongsTo('post') post;\n }\n ```\n\n You can avoid passing a string as the first parameter. In that case Ember Data\n will infer the type from the key name.\n\n ```app/models/comment.js\n import Model, { belongsTo } from '@ember-data/model';\n\n export default class CommentModel extends Model {\n @belongsTo post;\n }\n ```\n\n will lookup for a Post type.\n\n #### Sync relationships\n\n Ember Data resolves sync relationships with the related resources\n available in its local store, hence it is expected these resources\n to be loaded before or along-side the primary resource.\n\n ```app/models/comment.js\n import Model, { belongsTo } from '@ember-data/model';\n\n export default class CommentModel extends Model {\n @belongsTo('post', {\n async: false\n })\n post;\n }\n ```\n\n In contrast to async relationship, accessing a sync relationship\n will always return the record (Model instance) for the existing\n local resource, or null. But it will error on access when\n a related resource is known to exist and it has not been loaded.\n\n ```\n let post = comment.get('post');\n\n ```\n\n @method belongsTo\n @public\n @static\n @for @ember-data/model\n @param {String} modelName (optional) type of the relationship\n @param {Object} options (optional) a hash of options\n @return {Ember.computed} relationship\n */\n function belongsTo(modelName, options) {\n let opts, userEnteredModelName;\n if (typeof modelName === 'object') {\n opts = modelName;\n userEnteredModelName = undefined;\n } else {\n opts = options;\n userEnteredModelName = modelName;\n }\n (!(typeof userEnteredModelName === 'string' || typeof userEnteredModelName === 'undefined') && debug.assert('The first argument to belongsTo must be a string representing a model type key, not an instance of ' + debug.inspect(userEnteredModelName) + \". E.g., to define a relation to the Person model, use belongsTo('person')\", typeof userEnteredModelName === 'string' || typeof userEnteredModelName === 'undefined'));\n opts = opts || {};\n if (!('async' in opts)) {\n opts.async = true;\n }\n let meta = {\n type: userEnteredModelName,\n isRelationship: true,\n options: opts,\n kind: 'belongsTo',\n name: 'Belongs To',\n key: null\n };\n return EmberObject.computed({\n get(key) {\n {\n if (['_internalModel', 'recordData', 'currentState'].indexOf(key) !== -1) {\n throw new Error(`'${key}' is a reserved property name on instances of classes extending Model. Please choose a different property name for your belongsTo on ${this.constructor.toString()}`);\n }\n if (Object.prototype.hasOwnProperty.call(opts, 'serialize')) {\n (debug.warn(`You provided a serialize option on the \"${key}\" property in the \"${this._internalModel.modelName}\" class, this belongs in the serializer. See Serializer and it's implementations https://api.emberjs.com/ember-data/release/classes/Serializer`, false, {\n id: 'ds.model.serialize-option-in-belongs-to'\n }));\n }\n if (Object.prototype.hasOwnProperty.call(opts, 'embedded')) {\n (debug.warn(`You provided an embedded option on the \"${key}\" property in the \"${this._internalModel.modelName}\" class, this belongs in the serializer. See EmbeddedRecordsMixin https://api.emberjs.com/ember-data/release/classes/EmbeddedRecordsMixin`, false, {\n id: 'ds.model.embedded-option-in-belongs-to'\n }));\n }\n }\n return this._internalModel.getBelongsTo(key);\n },\n set(key, value) {\n {\n if (['_internalModel', 'recordData', 'currentState'].indexOf(key) !== -1) {\n throw new Error(`'${key}' is a reserved property name on instances of classes extending Model. Please choose a different property name for your belongsTo on ${this.constructor.toString()}`);\n }\n }\n this.store._backburner.join(() => {\n this._internalModel.setDirtyBelongsTo(key, value);\n });\n return this._internalModel.getBelongsTo(key);\n }\n }).meta(meta);\n }\n var belongsTo$1 = computedMacroWithOptionalParams(belongsTo);\n\n /**\n `hasMany` is used to define One-To-Many and Many-To-Many\n relationships on a [Model](/ember-data/release/classes/Model).\n\n `hasMany` takes an optional hash as a second parameter, currently\n supported options are:\n\n - `async`: A boolean value used to explicitly declare this to be an async relationship. The default is true.\n - `inverse`: A string used to identify the inverse property on a related model.\n - `polymorphic` A boolean value to mark the relationship as polymorphic\n\n #### One-To-Many\n To declare a one-to-many relationship between two models, use\n `belongsTo` in combination with `hasMany`, like this:\n\n ```app/models/post.js\n import Model, { hasMany } from '@ember-data/model';\n\n export default class PostModel extends Model {\n @hasMany('comment') comments;\n }\n ```\n\n ```app/models/comment.js\n import Model, { belongsTo } from '@ember-data/model';\n\n export default class CommentModel extends Model {\n @belongsTo('post') post;\n }\n ```\n\n #### Many-To-Many\n To declare a many-to-many relationship between two models, use\n `hasMany`:\n\n ```app/models/post.js\n import Model, { hasMany } from '@ember-data/model';\n\n export default class PostModel extends Model {\n @hasMany('tag') tags;\n }\n ```\n\n ```app/models/tag.js\n import Model, { hasMany } from '@ember-data/model';\n\n export default class TagModel extends Model {\n @hasMany('post') posts;\n }\n ```\n\n You can avoid passing a string as the first parameter. In that case Ember Data\n will infer the type from the singularized key name.\n\n ```app/models/post.js\n import Model, { hasMany } from '@ember-data/model';\n\n export default class PostModel extends Model {\n @hasMany tags;\n }\n ```\n\n will lookup for a Tag type.\n\n #### Explicit Inverses\n\n Ember Data will do its best to discover which relationships map to\n one another. In the one-to-many code above, for example, Ember Data\n can figure out that changing the `comments` relationship should update\n the `post` relationship on the inverse because post is the only\n relationship to that model.\n\n However, sometimes you may have multiple `belongsTo`/`hasMany` for the\n same type. You can specify which property on the related model is\n the inverse using `hasMany`'s `inverse` option:\n\n ```app/models/comment.js\n import Model, { belongsTo } from '@ember-data/model';\n\n export default class CommentModel extends Model {\n @belongsTo('post') onePost;\n @belongsTo('post') twoPost\n @belongsTo('post') redPost;\n @belongsTo('post') bluePost;\n }\n ```\n\n ```app/models/post.js\n import Model from '@ember-data/model';\n import { hasMany } from '@ember-decorators/data';\n\n export default class PostModel extends Model {\n @hasMany('comment', {\n inverse: 'redPost'\n })\n comments;\n }\n ```\n\n You can also specify an inverse on a `belongsTo`, which works how\n you'd expect.\n\n #### Sync relationships\n\n Ember Data resolves sync relationships with the related resources\n available in its local store, hence it is expected these resources\n to be loaded before or along-side the primary resource.\n\n ```app/models/post.js\n import Model, { hasMany } from '@ember-data/model';\n\n export default class PostModel extends Model {\n @hasMany('comment', {\n async: false\n })\n comments;\n }\n ```\n\n In contrast to async relationship, accessing a sync relationship\n will always return a [ManyArray](/ember-data/release/classes/ManyArray) instance\n containing the existing local resources. But it will error on access\n when any of the known related resources have not been loaded.\n\n ```\n post.get('comments').forEach((comment) => {\n\n });\n\n ```\n\n If you are using `links` with sync relationships, you have to use\n `ref.reload` to fetch the resources.\n\n @method hasMany\n @public\n @static\n @for @ember-data/model\n @param {String} type (optional) type of the relationship\n @param {Object} options (optional) a hash of options\n @return {Ember.computed} relationship\n */\n function hasMany(type, options) {\n if (typeof type === 'object') {\n options = type;\n type = undefined;\n }\n (!(typeof type === 'string' || typeof type === 'undefined') && debug.assert(`The first argument to hasMany must be a string representing a model type key, not an instance of ${debug.inspect(type)}. E.g., to define a relation to the Comment model, use hasMany('comment')`, typeof type === 'string' || typeof type === 'undefined'));\n options = options || {};\n if (!('async' in options)) {\n options.async = true;\n }\n\n // Metadata about relationships is stored on the meta of\n // the relationship. This is used for introspection and\n // serialization. Note that `key` is populated lazily\n // the first time the CP is called.\n let meta = {\n type,\n options,\n isRelationship: true,\n kind: 'hasMany',\n name: 'Has Many',\n key: null\n };\n return EmberObject.computed({\n get(key) {\n {\n if (['_internalModel', 'recordData', 'currentState'].indexOf(key) !== -1) {\n throw new Error(`'${key}' is a reserved property name on instances of classes extending Model. Please choose a different property name for your hasMany on ${this.constructor.toString()}`);\n }\n }\n return this._internalModel.getHasMany(key);\n },\n set(key, records) {\n {\n if (['_internalModel', 'recordData', 'currentState'].indexOf(key) !== -1) {\n throw new Error(`'${key}' is a reserved property name on instances of classes extending Model. Please choose a different property name for your hasMany on ${this.constructor.toString()}`);\n }\n }\n let internalModel = this._internalModel;\n this.store._backburner.join(() => {\n internalModel.setDirtyHasMany(key, records);\n });\n return internalModel.getHasMany(key);\n }\n }).meta(meta);\n }\n var hasMany$1 = computedMacroWithOptionalParams(hasMany);\n\n /**\n @module @ember-data/store\n */\n\n /**\n Holds validation errors for a given record, organized by attribute names.\n\n This class is not directly instantiable.\n\n Every `Model` has an `errors` property that is an instance of\n `Errors`. This can be used to display validation error\n messages returned from the server when a `record.save()` rejects.\n\n For Example, if you had a `User` model that looked like this:\n\n ```app/models/user.js\n import Model, { attr } from '@ember-data/model';\n\n export default class UserModel extends Model {\n @attr('string') username;\n @attr('string') email;\n }\n ```\n And you attempted to save a record that did not validate on the backend:\n\n ```javascript\n let user = store.createRecord('user', {\n username: 'tomster',\n email: 'invalidEmail'\n });\n user.save();\n ```\n\n Your backend would be expected to return an error response that described\n the problem, so that error messages can be generated on the app.\n\n API responses will be translated into instances of `Errors` differently,\n depending on the specific combination of adapter and serializer used. You\n may want to check the documentation or the source code of the libraries\n that you are using, to know how they expect errors to be communicated.\n\n Errors can be displayed to the user by accessing their property name\n to get an array of all the error objects for that property. Each\n error object is a JavaScript object with two keys:\n\n - `message` A string containing the error message from the backend\n - `attribute` The name of the property associated with this error message\n\n ```handlebars\n \n {{#each @model.errors.username as |error|}}\n
\n {{error.message}}\n
\n {{/each}}\n\n \n {{#each @model.errors.email as |error|}}\n
\n {{error.message}}\n
\n {{/each}}\n ```\n\n You can also access the special `messages` property on the error\n object to get an array of all the error strings.\n\n ```handlebars\n {{#each @model.errors.messages as |message|}}\n
\n {{message}}\n
\n {{/each}}\n ```\n\n @class Errors\n @public\n @extends Ember.ArrayProxy\n */\n var Errors = ArrayProxy__default[\"default\"].extend({\n /**\n Register with target handler\n @method _registerHandlers\n @private\n */\n _registerHandlers(becameInvalid, becameValid) {\n this._registeredHandlers = {\n becameInvalid,\n becameValid\n };\n },\n /**\n @property errorsByAttributeName\n @type {MapWithDefault}\n @private\n */\n errorsByAttributeName: EmberObject.computed(function () {\n return new Map();\n }),\n /**\n Returns errors for a given attribute\n ```javascript\n let user = store.createRecord('user', {\n username: 'tomster',\n email: 'invalidEmail'\n });\n user.save().catch(function(){\n user.get('errors').errorsFor('email'); // returns:\n // [{attribute: \"email\", message: \"Doesn't look like a valid email.\"}]\n });\n ```\n @method errorsFor\n @public\n @param {String} attribute\n @return {Array}\n */\n errorsFor(attribute) {\n let map = EmberObject.get(this, 'errorsByAttributeName');\n let errors = map.get(attribute);\n if (errors === undefined) {\n errors = EmberArray.A();\n map.set(attribute, errors);\n }\n\n // Errors may be a native array with extensions turned on. Since we access\n // the array via a method, and not a computed or using `Ember.get`, it does\n // not entangle properly with autotracking, so we entangle manually by\n // getting the `[]` property.\n EmberObject.get(errors, '[]');\n return errors;\n },\n /**\n An array containing all of the error messages for this\n record. This is useful for displaying all errors to the user.\n ```handlebars\n {{#each @model.errors.messages as |message|}}\n
\n {{message}}\n
\n {{/each}}\n ```\n @property messages\n @public\n @type {Array}\n */\n messages: computed.mapBy('content', 'message'),\n /**\n @property content\n @type {Array}\n @private\n */\n content: EmberObject.computed(function () {\n return EmberArray.A();\n }),\n /**\n @method unknownProperty\n @private\n */\n unknownProperty(attribute) {\n let errors = this.errorsFor(attribute);\n if (errors.length === 0) {\n return undefined;\n }\n return errors;\n },\n /**\n Total number of errors.\n @property length\n @type {Number}\n @public\n @readOnly\n */\n\n /**\n `true` if we have no errors.\n @property isEmpty\n @type {Boolean}\n @public\n @readOnly\n */\n isEmpty: computed.not('length').readOnly(),\n /**\n Manually adds errors to the record. This will trigger the `becameInvalid` event/ lifecycle method on\n the record and transition the record into an `invalid` state.\n Example\n ```javascript\n let errors = get(user, 'errors');\n // add multiple errors\n errors.add('password', [\n 'Must be at least 12 characters',\n 'Must contain at least one symbol',\n 'Cannot contain your name'\n ]);\n errors.errorsFor('password');\n // =>\n // [\n // { attribute: 'password', message: 'Must be at least 12 characters' },\n // { attribute: 'password', message: 'Must contain at least one symbol' },\n // { attribute: 'password', message: 'Cannot contain your name' },\n // ]\n // add a single error\n errors.add('username', 'This field is required');\n errors.errorsFor('username');\n // =>\n // [\n // { attribute: 'username', message: 'This field is required' },\n // ]\n ```\n @method add\n @public\n @param {string} attribute - the property name of an attribute or relationship\n @param {string[]|string} messages - an error message or array of error messages for the attribute\n */\n add(attribute, messages) {\n let wasEmpty = EmberObject.get(this, 'isEmpty');\n this._add(attribute, messages);\n if (wasEmpty && !EmberObject.get(this, 'isEmpty')) {\n this._registeredHandlers && this._registeredHandlers.becameInvalid();\n }\n },\n /**\n Adds error messages to a given attribute without sending event.\n @method _add\n @private\n */\n _add(attribute, messages) {\n messages = this._findOrCreateMessages(attribute, messages);\n this.addObjects(messages);\n this.errorsFor(attribute).addObjects(messages);\n this.notifyPropertyChange(attribute);\n },\n /**\n @method _findOrCreateMessages\n @private\n */\n _findOrCreateMessages(attribute, messages) {\n let errors = this.errorsFor(attribute);\n let messagesArray = EmberArray.makeArray(messages);\n let _messages = new Array(messagesArray.length);\n for (let i = 0; i < messagesArray.length; i++) {\n let message = messagesArray[i];\n let err = errors.findBy('message', message);\n if (err) {\n _messages[i] = err;\n } else {\n _messages[i] = {\n attribute: attribute,\n message: message\n };\n }\n }\n return _messages;\n },\n /**\n Manually removes all errors for a given member from the record.\n This will transition the record into a `valid` state, and\n triggers the `becameValid` event and lifecycle method.\n Example:\n ```javascript\n let errors = get('user', errors);\n errors.add('phone', ['error-1', 'error-2']);\n errors.errorsFor('phone');\n // =>\n // [\n // { attribute: 'phone', message: 'error-1' },\n // { attribute: 'phone', message: 'error-2' },\n // ]\n errors.remove('phone');\n errors.errorsFor('phone');\n // => undefined\n ```\n @method remove\n @public\n @param {string} member - the property name of an attribute or relationship\n */\n remove(attribute) {\n if (EmberObject.get(this, 'isEmpty')) {\n return;\n }\n this._remove(attribute);\n if (EmberObject.get(this, 'isEmpty')) {\n this._registeredHandlers && this._registeredHandlers.becameValid();\n }\n },\n /**\n Removes all error messages from the given attribute without sending event.\n @method _remove\n @private\n */\n _remove(attribute) {\n if (EmberObject.get(this, 'isEmpty')) {\n return;\n }\n let content = this.rejectBy('attribute', attribute);\n EmberObject.get(this, 'content').setObjects(content);\n\n // Although errorsByAttributeName.delete is technically enough to sync errors state, we also\n // must mutate the array as well for autotracking\n let errors = this.errorsFor(attribute);\n for (let i = 0; i < errors.length; i++) {\n if (errors[i].attribute === attribute) {\n // .replace from Ember.NativeArray is necessary. JS splice will not work.\n errors.replace(i, 1);\n }\n }\n EmberObject.get(this, 'errorsByAttributeName').delete(attribute);\n this.notifyPropertyChange(attribute);\n this.notifyPropertyChange('length');\n },\n /**\n Manually clears all errors for the record.\n This will transition the record into a `valid` state, and\n will trigger the `becameValid` event and lifecycle method.\n Example:\n ```javascript\n let errors = get('user', errors);\n errors.add('username', ['error-a']);\n errors.add('phone', ['error-1', 'error-2']);\n errors.errorsFor('username');\n // =>\n // [\n // { attribute: 'username', message: 'error-a' },\n // ]\n errors.errorsFor('phone');\n // =>\n // [\n // { attribute: 'phone', message: 'error-1' },\n // { attribute: 'phone', message: 'error-2' },\n // ]\n errors.clear();\n errors.errorsFor('username');\n // => undefined\n errors.errorsFor('phone');\n // => undefined\n errors.get('messages')\n // => []\n ```\n @method clear\n @public\n */\n clear() {\n if (EmberObject.get(this, 'isEmpty')) {\n return;\n }\n this._clear();\n this._registeredHandlers && this._registeredHandlers.becameValid();\n },\n /**\n Removes all error messages.\n to the record.\n @method _clear\n @private\n */\n _clear() {\n if (EmberObject.get(this, 'isEmpty')) {\n return;\n }\n let errorsByAttributeName = EmberObject.get(this, 'errorsByAttributeName');\n let attributes = [];\n errorsByAttributeName.forEach(function (_, attribute) {\n attributes.push(attribute);\n });\n errorsByAttributeName.clear();\n attributes.forEach(attribute => {\n this.notifyPropertyChange(attribute);\n });\n ArrayProxy__default[\"default\"].prototype.clear.call(this);\n },\n /**\n Checks if there are error messages for the given attribute.\n ```app/controllers/user/edit.js\n import Controller from '@ember/controller';\n import { action } from '@ember/object';\n export default class UserEditController extends Controller {\n @action\n save(user) {\n if (user.get('errors').has('email')) {\n return alert('Please update your email before attempting to save.');\n }\n user.save();\n }\n }\n ```\n @method has\n @public\n @param {String} attribute\n @return {Boolean} true if there some errors on given attribute\n */\n has(attribute) {\n return this.errorsFor(attribute).length > 0;\n }\n });\n\n function notifyChanges(identifier, value, key, record, store) {\n if (value === 'attributes') {\n if (key) {\n notifyAttribute(store, identifier, key, record);\n } else {\n record.eachAttribute(key => {\n notifyAttribute(store, identifier, key, record);\n });\n }\n } else if (value === 'relationships') {\n if (key) {\n let meta = record.constructor.relationshipsByName.get(key);\n notifyRelationship(store, identifier, key, record, meta);\n } else {\n record.eachRelationship((key, meta) => {\n notifyRelationship(store, identifier, key, record, meta);\n });\n }\n } else if (value === 'identity') {\n record.notifyPropertyChange('id');\n }\n }\n function notifyRelationship(store, identifier, key, record, meta) {\n let internalModel = store._internalModelForResource(identifier);\n if (meta.kind === 'belongsTo') {\n record.notifyPropertyChange(key);\n } else if (meta.kind === 'hasMany') {\n let manyArray = internalModel._manyArrayCache[key];\n if (manyArray) {\n manyArray.notify();\n\n //We need to notifyPropertyChange in the adding case because we need to make sure\n //we fetch the newly added record in case it is unloaded\n //TODO(Igor): Consider whether we could do this only if the record state is unloaded\n if (!meta.options || meta.options.async || meta.options.async === undefined) {\n record.notifyPropertyChange(key);\n }\n }\n }\n }\n function notifyAttribute(store, identifier, key, record) {\n let currentValue = internals.cacheFor(record, key);\n let internalModel = store._internalModelForResource(identifier);\n if (currentValue !== internalModel._recordData.getAttr(key)) {\n record.notifyPropertyChange(key);\n }\n }\n\n var _class$2, _descriptor$2, _class2, _descriptor2$1;\n function _initializerDefineProperty$2(e, i, r, l) { r && Object.defineProperty(e, i, { enumerable: r.enumerable, configurable: r.configurable, writable: r.writable, value: r.initializer ? r.initializer.call(l) : void 0 }); }\n function _applyDecoratedDescriptor$2(i, e, r, n, l) { var a = {}; return Object.keys(n).forEach(function (i) { a[i] = n[i]; }), a.enumerable = !!a.enumerable, a.configurable = !!a.configurable, (\"value\" in a || a.initializer) && (a.writable = !0), a = r.slice().reverse().reduce(function (r, n) { return n(i, e, r) || r; }, a), l && void 0 !== a.initializer && (a.value = a.initializer ? a.initializer.call(l) : void 0, a.initializer = void 0), void 0 === a.initializer ? (Object.defineProperty(i, e, a), null) : a; }\n function isInvalidError(error) {\n return error && error.isAdapterError === true && error.code === 'InvalidError';\n }\n\n /**\n * Tag provides a cache for a getter\n * that recomputes only when a specific\n * tracked property that it manages is dirtied.\n *\n * This allows us to bust the cache for a value\n * that otherwise doesn't access anything tracked\n * as well as control the timing of that notification.\n *\n * @internal\n */\n let Tag = (_class$2 = class Tag {\n constructor() {\n _initializerDefineProperty$2(this, \"_tracking\", _descriptor$2, this);\n this.rev = 1;\n this.isDirty = true;\n this.value = undefined;\n }\n subscribe() {\n this._tracking;\n }\n notify() {\n this.isDirty = true;\n this._tracking = this.rev;\n this.rev++;\n }\n consume(v) {\n this.isDirty = false;\n this.value = v; // set cached value\n }\n }, _descriptor$2 = _applyDecoratedDescriptor$2(_class$2.prototype, \"_tracking\", [tracking.tracked], {\n configurable: true,\n enumerable: true,\n writable: true,\n initializer: function () {\n return 0;\n }\n }), _class$2);\n const Tags = new WeakMap();\n function getTag(record, key) {\n let tags = Tags.get(record);\n if (!tags) {\n tags = Object.create(null);\n Tags.set(record, tags);\n }\n return tags[key] = tags[key] || new Tag();\n }\n function peekTag(record, key) {\n let tags = Tags.get(record);\n return tags && tags[key];\n }\n\n /**\n * A decorattor that caches a getter while\n * providing the ability to bust that cache\n * when we so choose in a way that notifies\n * glimmer's tracking system.\n *\n * @internal\n */\n function tagged(_target, key, desc) {\n const getter = desc.get;\n const setter = desc.set;\n desc.get = function () {\n let tag = getTag(this, key);\n tag.subscribe();\n if (tag.isDirty) {\n tag.consume(getter.call(this));\n }\n return tag.value;\n };\n desc.set = function (v) {\n getTag(this, key); // ensure tag is setup in case we want to use it.\n // probably notify here but not yet.\n setter.call(this, v);\n };\n compat.dependentKeyCompat(desc);\n return desc;\n }\n\n /**\n Historically InternalModel managed a state machine\n the currentState for which was reflected onto Model.\n\n This implements the flags and stateName for backwards compat\n with the state tree that used to be possible (listed below).\n\n stateName and dirtyType are candidates for deprecation.\n\n root\n empty\n deleted // hidden from stateName\n preloaded // hidden from stateName\n\n loading\n empty // hidden from stateName\n preloaded // hidden from stateName\n\n loaded\n saved\n updated\n uncommitted\n invalid\n inFlight\n created\n uncommitted\n invalid\n inFlight\n\n deleted\n saved\n new // hidden from stateName\n uncommitted\n invalid\n inFlight\n\n @internal\n */\n let RecordState = (_class2 = class RecordState {\n constructor(record) {\n _initializerDefineProperty$2(this, \"isSaving\", _descriptor2$1, this);\n const {\n store\n } = record;\n let id = record._internalModel.identifier;\n this.record = record;\n this.recordData = record._internalModel._recordData;\n this.pendingCount = 0;\n this.fulfilledCount = 0;\n this.rejectedCount = 0;\n this._errorRequests = [];\n this._lastError = null;\n let requests = store.getRequestStateService();\n let notifications = store._notificationManager;\n requests.subscribeForRecord(id, req => {\n if (req.type === 'mutation') {\n switch (req.state) {\n case 'pending':\n this.isSaving = true;\n break;\n case 'rejected':\n this.isSaving = false;\n this._lastError = req;\n if (!(req.response && isInvalidError(req.response.data))) {\n this._errorRequests.push(req);\n }\n notifyErrorsStateChanged(this);\n break;\n case 'fulfilled':\n this._errorRequests = [];\n this._lastError = null;\n this.isSaving = false;\n notifyErrorsStateChanged(this);\n break;\n }\n } else {\n switch (req.state) {\n case 'pending':\n this.pendingCount++;\n this.notify('isLoading');\n break;\n case 'rejected':\n this.pendingCount--;\n this._lastError = req;\n if (!(req.response && isInvalidError(req.response.data))) {\n this._errorRequests.push(req);\n }\n this.notify('isLoading');\n notifyErrorsStateChanged(this);\n break;\n case 'fulfilled':\n this.pendingCount--;\n this.fulfilledCount++;\n this.notify('isLoading');\n this.notify('isDirty');\n notifyErrorsStateChanged(this);\n this._errorRequests = [];\n this._lastError = null;\n break;\n }\n }\n });\n notifications.subscribe(id, (identifier, type, key) => {\n notifyChanges(identifier, type, key, record, store);\n switch (type) {\n case 'state':\n this.notify('isNew');\n this.notify('isDeleted');\n this.notify('isDirty');\n break;\n case 'attributes':\n this.notify('isEmpty');\n this.notify('isDirty');\n break;\n case 'unload':\n this.notify('isNew');\n this.notify('isDeleted');\n break;\n case 'errors':\n // we only hit this if a foreign RecordData notifies\n // errors changed. Our own implementation does not\n // take this path currently, but we should probably\n // fix that.\n this.updateInvalidErrors();\n this.notify('isValid');\n break;\n }\n });\n }\n notify(key) {\n getTag(this, key).notify();\n }\n updateInvalidErrors() {\n let jsonApiErrors = this.recordData.getErrors();\n const {\n errors\n } = this.record;\n errors._clear();\n let newErrors = Private.errorsArrayToHash(jsonApiErrors);\n let errorKeys = Object.keys(newErrors);\n for (let i = 0; i < errorKeys.length; i++) {\n errors._add(errorKeys[i], newErrors[errorKeys[i]]);\n }\n }\n cleanErrorRequests() {\n this.notify('isValid');\n this.notify('isError');\n this.notify('adapterError');\n this._errorRequests = [];\n this._lastError = null;\n }\n get isLoading() {\n return !this.isLoaded && this.pendingCount > 0 && this.fulfilledCount === 0;\n }\n get isLoaded() {\n if (this.isNew) {\n return true;\n }\n return this.fulfilledCount > 0 || !this.isEmpty;\n }\n get isSaved() {\n let rd = this.recordData;\n if (this.isDeleted) {\n (!(rd.isDeletionCommitted) && debug.assert(`Expected RecordData to implement isDeletionCommitted()`, rd.isDeletionCommitted));\n return rd.isDeletionCommitted();\n }\n if (this.isNew || this.isEmpty || !this.isValid || this.isDirty || this.isLoading) {\n return false;\n }\n return true;\n }\n get isEmpty() {\n let rd = this.recordData;\n // TODO this is not actually an RFC'd concept. Determine the\n // correct heuristic to replace this with.\n (!(rd.isEmpty) && debug.assert(`Expected RecordData to implement isEmpty()`, rd.isEmpty));\n return !this.isNew && rd.isEmpty();\n }\n get isNew() {\n let rd = this.recordData;\n (!(rd.isNew) && debug.assert(`Expected RecordData to implement isNew()`, rd.isNew));\n return rd.isNew();\n }\n get isDeleted() {\n let rd = this.recordData;\n (!(rd.isDeleted) && debug.assert(`Expected RecordData to implement isDeleted()`, rd.isDeleted));\n return rd.isDeleted();\n }\n get isValid() {\n return this.record.errors.length === 0;\n }\n get isDirty() {\n let rd = this.recordData;\n (!(rd.hasChangedAttributes) && debug.assert(`Expected RecordData to implement hasChangedAttributes()`, rd.hasChangedAttributes));\n (!(rd.isDeletionCommitted) && debug.assert(`Expected RecordData to implement isDeletionCommitted()`, rd.isDeletionCommitted));\n if (rd.isDeletionCommitted() || this.isDeleted && this.isNew) {\n return false;\n }\n return this.isNew || rd.hasChangedAttributes();\n }\n get isError() {\n let errorReq = this._errorRequests[this._errorRequests.length - 1];\n if (!errorReq) {\n return false;\n } else {\n return true;\n }\n }\n get adapterError() {\n let request = this._lastError;\n if (!request) {\n return null;\n }\n return request.state === 'rejected' && request.response.data;\n }\n get isPreloaded() {\n return !this.isEmpty && this.isLoading;\n }\n get stateName() {\n // we might be empty while loading so check this first\n if (this.isLoading) {\n return 'root.loading';\n\n // got nothing yet or were unloaded\n } else if (this.isEmpty) {\n return 'root.empty';\n\n // deleted substates\n } else if (this.isDeleted) {\n if (this.isSaving) {\n return 'root.deleted.inFlight';\n } else if (this.isSaved) {\n // TODO ensure isSaved isn't true from previous requests\n return 'root.deleted.saved';\n } else if (!this.isValid) {\n return 'root.deleted.invalid';\n } else {\n return 'root.deleted.uncommitted';\n }\n\n // loaded.created substates\n } else if (this.isNew) {\n if (this.isSaving) {\n return 'root.loaded.created.inFlight';\n } else if (!this.isValid) {\n return 'root.loaded.created.invalid';\n }\n return 'root.loaded.created.uncommitted';\n\n // loaded.updated substates\n } else if (this.isSaving) {\n return 'root.loaded.updated.inFlight';\n } else if (!this.isValid) {\n return 'root.loaded.updated.invalid';\n } else if (this.isDirty) {\n return 'root.loaded.updated.uncommitted';\n\n // if nothing remains, we are loaded saved!\n } else {\n return 'root.loaded.saved';\n }\n }\n get dirtyType() {\n // we might be empty while loading so check this first\n if (this.isLoading || this.isEmpty) {\n return '';\n\n // deleted substates\n } else if (this.isDeleted) {\n return 'deleted';\n\n // loaded.created substates\n } else if (this.isNew) {\n return 'created';\n\n // loaded.updated substates\n } else if (this.isSaving || !this.isValid || this.isDirty) {\n return 'updated';\n\n // if nothing remains, we are loaded saved!\n } else {\n return '';\n }\n }\n }, _descriptor2$1 = _applyDecoratedDescriptor$2(_class2.prototype, \"isSaving\", [tracking.tracked], {\n configurable: true,\n enumerable: true,\n writable: true,\n initializer: function () {\n return false;\n }\n }), _applyDecoratedDescriptor$2(_class2.prototype, \"isLoading\", [tagged], Object.getOwnPropertyDescriptor(_class2.prototype, \"isLoading\"), _class2.prototype), _applyDecoratedDescriptor$2(_class2.prototype, \"isLoaded\", [tagged], Object.getOwnPropertyDescriptor(_class2.prototype, \"isLoaded\"), _class2.prototype), _applyDecoratedDescriptor$2(_class2.prototype, \"isSaved\", [tagged], Object.getOwnPropertyDescriptor(_class2.prototype, \"isSaved\"), _class2.prototype), _applyDecoratedDescriptor$2(_class2.prototype, \"isEmpty\", [tagged], Object.getOwnPropertyDescriptor(_class2.prototype, \"isEmpty\"), _class2.prototype), _applyDecoratedDescriptor$2(_class2.prototype, \"isNew\", [tagged], Object.getOwnPropertyDescriptor(_class2.prototype, \"isNew\"), _class2.prototype), _applyDecoratedDescriptor$2(_class2.prototype, \"isDeleted\", [tagged], Object.getOwnPropertyDescriptor(_class2.prototype, \"isDeleted\"), _class2.prototype), _applyDecoratedDescriptor$2(_class2.prototype, \"isValid\", [tagged], Object.getOwnPropertyDescriptor(_class2.prototype, \"isValid\"), _class2.prototype), _applyDecoratedDescriptor$2(_class2.prototype, \"isDirty\", [tagged], Object.getOwnPropertyDescriptor(_class2.prototype, \"isDirty\"), _class2.prototype), _applyDecoratedDescriptor$2(_class2.prototype, \"isError\", [tagged], Object.getOwnPropertyDescriptor(_class2.prototype, \"isError\"), _class2.prototype), _applyDecoratedDescriptor$2(_class2.prototype, \"adapterError\", [tagged], Object.getOwnPropertyDescriptor(_class2.prototype, \"adapterError\"), _class2.prototype), _applyDecoratedDescriptor$2(_class2.prototype, \"isPreloaded\", [emberCachedDecoratorPolyfill.cached], Object.getOwnPropertyDescriptor(_class2.prototype, \"isPreloaded\"), _class2.prototype), _applyDecoratedDescriptor$2(_class2.prototype, \"stateName\", [emberCachedDecoratorPolyfill.cached], Object.getOwnPropertyDescriptor(_class2.prototype, \"stateName\"), _class2.prototype), _applyDecoratedDescriptor$2(_class2.prototype, \"dirtyType\", [emberCachedDecoratorPolyfill.cached], Object.getOwnPropertyDescriptor(_class2.prototype, \"dirtyType\"), _class2.prototype), _class2);\n function notifyErrorsStateChanged(state) {\n state.notify('isValid');\n state.notify('isError');\n state.notify('adapterError');\n }\n\n /**\n @module @ember-data/store\n */\n\n function typeForRelationshipMeta(meta) {\n let modelName = Private.normalizeModelName(meta.type || meta.key);\n if (meta.kind === 'hasMany') {\n modelName = emberInflector.singularize(modelName);\n }\n return modelName;\n }\n function shouldFindInverse(relationshipMeta) {\n let options = relationshipMeta.options;\n return !(options && options.inverse === null);\n }\n class RelationshipDefinition {\n constructor(meta) {\n this._type = '';\n this.__inverseKey = '';\n this.__inverseIsAsync = true;\n this.__hasCalculatedInverse = false;\n this.parentModelName = meta.parentModelName;\n this.meta = meta;\n }\n\n /**\n * @internal\n * @deprecated\n */\n get key() {\n return this.meta.key;\n }\n get kind() {\n return this.meta.kind;\n }\n get type() {\n if (this._type) {\n return this._type;\n }\n this._type = typeForRelationshipMeta(this.meta);\n return this._type;\n }\n get options() {\n return this.meta.options;\n }\n get name() {\n return this.meta.name;\n }\n _inverseKey(store, modelClass) {\n if (this.__hasCalculatedInverse === false) {\n this._calculateInverse(store, modelClass);\n }\n return this.__inverseKey;\n }\n _inverseIsAsync(store, modelClass) {\n if (this.__hasCalculatedInverse === false) {\n this._calculateInverse(store, modelClass);\n }\n return this.__inverseIsAsync;\n }\n _calculateInverse(store, modelClass) {\n this.__hasCalculatedInverse = true;\n let inverseKey, inverseIsAsync;\n let inverse = null;\n if (shouldFindInverse(this.meta)) {\n inverse = modelClass.inverseFor(this.key, store);\n } else {\n modelClass.typeForRelationship(this.key, store);\n }\n if (inverse) {\n inverseKey = inverse.name;\n inverseIsAsync = isRelationshipAsync(inverse);\n } else {\n inverseKey = null;\n inverseIsAsync = false;\n }\n this.__inverseKey = inverseKey;\n this.__inverseIsAsync = inverseIsAsync;\n }\n }\n function isRelationshipAsync(meta) {\n let inverseAsync = meta.options && meta.options.async;\n return typeof inverseAsync === 'undefined' ? true : inverseAsync;\n }\n function relationshipFromMeta(meta) {\n return new RelationshipDefinition(meta);\n }\n\n var _class$1, _descriptor$1, _Model;\n function _initializerDefineProperty$1(e, i, r, l) { r && Object.defineProperty(e, i, { enumerable: r.enumerable, configurable: r.configurable, writable: r.writable, value: r.initializer ? r.initializer.call(l) : void 0 }); }\n function _applyDecoratedDescriptor$1(i, e, r, n, l) { var a = {}; return Object.keys(n).forEach(function (i) { a[i] = n[i]; }), a.enumerable = !!a.enumerable, a.configurable = !!a.configurable, (\"value\" in a || a.initializer) && (a.writable = !0), a = r.slice().reverse().reduce(function (r, n) { return n(i, e, r) || r; }, a), l && void 0 !== a.initializer && (a.value = a.initializer ? a.initializer.call(l) : void 0, a.initializer = void 0), void 0 === a.initializer ? (Object.defineProperty(i, e, a), null) : a; }\n const {\n changeProperties\n } = Ember__default[\"default\"];\n function findPossibleInverses(type, inverseType, name, relationshipsSoFar) {\n let possibleRelationships = relationshipsSoFar || [];\n let relationshipMap = inverseType.relationships;\n if (!relationshipMap) {\n return possibleRelationships;\n }\n let relationshipsForType = relationshipMap.get(type.modelName);\n let relationships = Array.isArray(relationshipsForType) ? relationshipsForType.filter(relationship => {\n let optionsForRelationship = inverseType.metaForProperty(relationship.name).options;\n if (!optionsForRelationship.inverse && optionsForRelationship.inverse !== null) {\n return true;\n }\n return name === optionsForRelationship.inverse;\n }) : null;\n if (relationships) {\n possibleRelationships.push.apply(possibleRelationships, relationships);\n }\n\n //Recurse to support polymorphism\n if (type.superclass) {\n findPossibleInverses(type.superclass, inverseType, name, possibleRelationships);\n }\n return possibleRelationships;\n }\n\n /*\n * This decorator allows us to lazily compute\n * an expensive getter on first-access and thereafter\n * never recompute it.\n */\n function computeOnce(target, key, desc) {\n const cache = new WeakMap();\n let getter = desc.get;\n desc.get = function () {\n let meta = cache.get(this);\n if (!meta) {\n meta = {\n hasComputed: false,\n value: undefined\n };\n cache.set(this, meta);\n }\n if (!meta.hasComputed) {\n meta.value = getter.call(this);\n meta.hasComputed = true;\n }\n return meta.value;\n };\n return desc;\n }\n\n /**\n Base class from which Models can be define.\n\n ```js\n import Model, { attr } from '@ember-data/model';\n\n export default class User extends Model {\n @attr name;\n }\n ```\n\n @class Model\n @public\n @extends Ember.EmberObject\n */\n let Model = (_class$1 = (_Model = class Model extends EmberObject__default[\"default\"] {\n constructor(...args) {\n super(...args);\n /**\n If `true` the store is attempting to reload the record from the adapter.\n Example\n ```javascript\n record.get('isReloading'); // false\n record.reload();\n record.get('isReloading'); // true\n ```\n @property isReloading\n @public\n @type {Boolean}\n @readOnly\n */\n _initializerDefineProperty$1(this, \"isReloading\", _descriptor$1, this);\n }\n init(options = {}) {\n const createProps = options._createProps;\n delete options._createProps;\n super.init(options);\n {\n if (!this._internalModel) {\n throw new EmberError__default[\"default\"]('You should not call `create` on a model. Instead, call `store.createRecord` with the attributes you would like to set.');\n }\n }\n this.___recordState = new RecordState(this);\n this.setProperties(createProps);\n }\n\n /**\n If this property is `true` the record is in the `empty`\n state. Empty is the first state all records enter after they have\n been created. Most records created by the store will quickly\n transition to the `loading` state if data needs to be fetched from\n the server or the `created` state if the record is created on the\n client. A record can also enter the empty state if the adapter is\n unable to locate the record.\n @property isEmpty\n @public\n @type {Boolean}\n @readOnly\n */\n get isEmpty() {\n return this.currentState.isEmpty;\n }\n\n /**\n If this property is `true` the record is in the `loading` state. A\n record enters this state when the store asks the adapter for its\n data. It remains in this state until the adapter provides the\n requested data.\n @property isLoading\n @public\n @type {Boolean}\n @readOnly\n */\n get isLoading() {\n return this.currentState.isLoading;\n }\n\n /**\n If this property is `true` the record is in the `loaded` state. A\n record enters this state when its data is populated. Most of a\n record's lifecycle is spent inside substates of the `loaded`\n state.\n Example\n ```javascript\n let record = store.createRecord('model');\n record.get('isLoaded'); // true\n store.findRecord('model', 1).then(function(model) {\n model.get('isLoaded'); // true\n });\n ```\n @property isLoaded\n @public\n @type {Boolean}\n @readOnly\n */\n get isLoaded() {\n return this.currentState.isLoaded;\n }\n\n /**\n If this property is `true` the record is in the `dirty` state. The\n record has local changes that have not yet been saved by the\n adapter. This includes records that have been created (but not yet\n saved) or deleted.\n Example\n ```javascript\n let record = store.createRecord('model');\n record.get('hasDirtyAttributes'); // true\n store.findRecord('model', 1).then(function(model) {\n model.get('hasDirtyAttributes'); // false\n model.set('foo', 'some value');\n model.get('hasDirtyAttributes'); // true\n });\n ```\n @since 1.13.0\n @property hasDirtyAttributes\n @public\n @type {Boolean}\n @readOnly\n */\n get hasDirtyAttributes() {\n return this.currentState.isDirty;\n }\n\n /**\n If this property is `true` the record is in the `saving` state. A\n record enters the saving state when `save` is called, but the\n adapter has not yet acknowledged that the changes have been\n persisted to the backend.\n Example\n ```javascript\n let record = store.createRecord('model');\n record.get('isSaving'); // false\n let promise = record.save();\n record.get('isSaving'); // true\n promise.then(function() {\n record.get('isSaving'); // false\n });\n ```\n @property isSaving\n @public\n @type {Boolean}\n @readOnly\n */\n get isSaving() {\n return this.currentState.isSaving;\n }\n\n /**\n If this property is `true` the record is in the `deleted` state\n and has been marked for deletion. When `isDeleted` is true and\n `hasDirtyAttributes` is true, the record is deleted locally but the deletion\n was not yet persisted. When `isSaving` is true, the change is\n in-flight. When both `hasDirtyAttributes` and `isSaving` are false, the\n change has persisted.\n Example\n ```javascript\n let record = store.createRecord('model');\n record.get('isDeleted'); // false\n record.deleteRecord();\n // Locally deleted\n record.get('isDeleted'); // true\n record.get('hasDirtyAttributes'); // true\n record.get('isSaving'); // false\n // Persisting the deletion\n let promise = record.save();\n record.get('isDeleted'); // true\n record.get('isSaving'); // true\n // Deletion Persisted\n promise.then(function() {\n record.get('isDeleted'); // true\n record.get('isSaving'); // false\n record.get('hasDirtyAttributes'); // false\n });\n ```\n @property isDeleted\n @public\n @type {Boolean}\n @readOnly\n */\n get isDeleted() {\n return this.currentState.isDeleted;\n }\n\n /**\n If this property is `true` the record is in the `new` state. A\n record will be in the `new` state when it has been created on the\n client and the adapter has not yet report that it was successfully\n saved.\n Example\n ```javascript\n let record = store.createRecord('model');\n record.get('isNew'); // true\n record.save().then(function(model) {\n model.get('isNew'); // false\n });\n ```\n @property isNew\n @public\n @type {Boolean}\n @readOnly\n */\n get isNew() {\n return this.currentState.isNew;\n }\n\n /**\n If this property is `true` the record is in the `valid` state.\n A record will be in the `valid` state when the adapter did not report any\n server-side validation failures.\n @property isValid\n @public\n @type {Boolean}\n @readOnly\n */\n get isValid() {\n return this.currentState.isValid;\n }\n\n /**\n If the record is in the dirty state this property will report what\n kind of change has caused it to move into the dirty\n state. Possible values are:\n - `created` The record has been created by the client and not yet saved to the adapter.\n - `updated` The record has been updated by the client and not yet saved to the adapter.\n - `deleted` The record has been deleted by the client and not yet saved to the adapter.\n Example\n ```javascript\n let record = store.createRecord('model');\n record.get('dirtyType'); // 'created'\n ```\n @property dirtyType\n @public\n @type {String}\n @readOnly\n */\n get dirtyType() {\n return this.currentState.dirtyType;\n }\n\n /**\n If `true` the adapter reported that it was unable to save local\n changes to the backend for any reason other than a server-side\n validation error.\n Example\n ```javascript\n record.get('isError'); // false\n record.set('foo', 'valid value');\n record.save().then(null, function() {\n record.get('isError'); // true\n });\n ```\n @property isError\n @public\n @type {Boolean}\n @readOnly\n */\n get isError() {\n return this.currentState.isError;\n }\n set isError(v) {\n {\n throw new Error(`isError is not directly settable`);\n }\n }\n /**\n All ember models have an id property. This is an identifier\n managed by an external source. These are always coerced to be\n strings before being used internally. Note when declaring the\n attributes for a model it is an error to declare an id\n attribute.\n ```javascript\n let record = store.createRecord('model');\n record.get('id'); // null\n store.findRecord('model', 1).then(function(model) {\n model.get('id'); // '1'\n });\n ```\n @property id\n @public\n @type {String}\n */\n get id() {\n // the _internalModel guard exists, because some dev-only deprecation code\n // (addListener via validatePropertyInjections) invokes toString before the\n // object is real.\n {\n if (!this._internalModel) {\n return void 0;\n }\n }\n return this._internalModel.id;\n }\n set id(id) {\n const normalizedId = Private.coerceId(id);\n if (normalizedId !== null) {\n this._internalModel.setId(normalizedId);\n }\n }\n\n /**\n @property currentState\n @private\n @type {Object}\n */\n get currentState() {\n return this.___recordState;\n }\n set currentState(_v) {\n throw new Error('cannot set currentState');\n }\n\n /**\n @property _internalModel\n @private\n @type {Object}\n */\n\n /**\n The store service instance which created this record instance\n @property store\n @public\n */\n\n /**\n When the record is in the `invalid` state this object will contain\n any errors returned by the adapter. When present the errors hash\n contains keys corresponding to the invalid property names\n and values which are arrays of Javascript objects with two keys:\n - `message` A string containing the error message from the backend\n - `attribute` The name of the property associated with this error message\n ```javascript\n record.get('errors.length'); // 0\n record.set('foo', 'invalid value');\n record.save().catch(function() {\n record.get('errors').get('foo');\n // [{message: 'foo should be a number.', attribute: 'foo'}]\n });\n ```\n The `errors` property is useful for displaying error messages to\n the user.\n ```handlebars\n \n {{#each @model.errors.username as |error|}}\n
\n {{error.message}}\n
\n {{/each}}\n \n {{#each @model.errors.email as |error|}}\n
\n {{error.message}}\n
\n {{/each}}\n ```\n You can also access the special `messages` property on the error\n object to get an array of all the error strings.\n ```handlebars\n {{#each @model.errors.messages as |message|}}\n
\n {{message}}\n
\n {{/each}}\n ```\n @property errors\n @public\n @type {Errors}\n */\n get errors() {\n let errors = Errors.create();\n errors._registerHandlers(() => {\n this._internalModel.send('becameInvalid');\n }, () => {\n this._internalModel.send('becameValid');\n });\n // TODO we should unify how errors gets populated\n // with the code managing the update. Probably a\n // lazy flush similar to retrieveLatest in ManyArray\n let recordData = Private.recordDataFor(this);\n let jsonApiErrors;\n if (recordData.getErrors) {\n jsonApiErrors = recordData.getErrors();\n if (jsonApiErrors) {\n let errorsHash = Private.errorsArrayToHash(jsonApiErrors);\n let errorKeys = Object.keys(errorsHash);\n for (let i = 0; i < errorKeys.length; i++) {\n errors._add(errorKeys[i], errorsHash[errorKeys[i]]);\n }\n }\n }\n return errors;\n }\n\n /**\n This property holds the `AdapterError` object with which\n last adapter operation was rejected.\n @property adapterError\n @public\n @type {AdapterError}\n */\n get adapterError() {\n return this.currentState.adapterError;\n }\n set adapterError(v) {\n throw new Error(`adapterError is not directly settable`);\n }\n\n /**\n Create a JSON representation of the record, using the serialization\n strategy of the store's adapter.\n `serialize` takes an optional hash as a parameter, currently\n supported options are:\n - `includeId`: `true` if the record's ID should be included in the\n JSON representation.\n @method serialize\n @public\n @param {Object} options\n @return {Object} an object whose values are primitive JSON values only\n */\n serialize(options) {\n return this._internalModel.createSnapshot().serialize(options);\n }\n\n /*\n We hook the default implementation to ensure\n our tagged properties are properly notified\n as well. We still super for everything because\n sync observers require a direct call occuring\n to trigger their flush. We wouldn't need to\n super in 4.0+ where sync observers are removed.\n */\n notifyPropertyChange(key) {\n let tag = peekTag(this, key);\n if (tag) {\n tag.notify();\n }\n super.notifyPropertyChange(key);\n }\n\n /**\n Marks the record as deleted but does not save it. You must call\n `save` afterwards if you want to persist it. You might use this\n method if you want to allow the user to still `rollbackAttributes()`\n after a delete was made.\n Example\n ```app/controllers/model/delete.js\n import Controller from '@ember/controller';\n import { action } from '@ember/object';\n export default class ModelDeleteController extends Controller {\n @action\n softDelete() {\n this.model.deleteRecord();\n }\n @action\n confirm() {\n this.model.save();\n }\n @action\n undo() {\n this.model.rollbackAttributes();\n }\n }\n ```\n @method deleteRecord\n @public\n */\n deleteRecord() {\n this.store.deleteRecord(this);\n }\n\n /**\n Same as `deleteRecord`, but saves the record immediately.\n Example\n ```app/controllers/model/delete.js\n import Controller from '@ember/controller';\n import { action } from '@ember/object';\n export default class ModelDeleteController extends Controller {\n @action\n delete() {\n this.model.destroyRecord().then(function() {\n this.transitionToRoute('model.index');\n });\n }\n }\n ```\n If you pass an object on the `adapterOptions` property of the options\n argument it will be passed to your adapter via the snapshot\n ```js\n record.destroyRecord({ adapterOptions: { subscribe: false } });\n ```\n ```app/adapters/post.js\n import MyCustomAdapter from './custom-adapter';\n export default class PostAdapter extends MyCustomAdapter {\n deleteRecord(store, type, snapshot) {\n if (snapshot.adapterOptions.subscribe) {\n // ...\n }\n // ...\n }\n }\n ```\n @method destroyRecord\n @public\n @param {Object} options\n @return {Promise} a promise that will be resolved when the adapter returns\n successfully or rejected if the adapter returns with an error.\n */\n destroyRecord(options) {\n this.deleteRecord();\n return this.save(options).then(_ => {\n runloop.run(() => {\n this.unloadRecord();\n });\n return this;\n });\n }\n\n /**\n Unloads the record from the store. This will not send a delete request\n to your server, it just unloads the record from memory.\n @method unloadRecord\n @public\n */\n unloadRecord() {\n if (this.isDestroyed) {\n return;\n }\n this.store.unloadRecord(this);\n }\n\n /**\n @method _notifyProperties\n @private\n */\n _notifyProperties(keys) {\n // changeProperties defers notifications until after the delegate\n // and protects with a try...finally block\n // previously used begin...endPropertyChanges but this is private API\n changeProperties(() => {\n let key;\n for (let i = 0, length = keys.length; i < length; i++) {\n key = keys[i];\n this.notifyPropertyChange(key);\n }\n });\n }\n\n /**\n Returns an object, whose keys are changed properties, and value is\n an [oldProp, newProp] array.\n The array represents the diff of the canonical state with the local state\n of the model. Note: if the model is created locally, the canonical state is\n empty since the adapter hasn't acknowledged the attributes yet:\n Example\n ```app/models/mascot.js\n import Model, { attr } from '@ember-data/model';\n export default class MascotModel extends Model {\n @attr('string') name;\n @attr('boolean', {\n defaultValue: false\n })\n isAdmin;\n }\n ```\n ```javascript\n let mascot = store.createRecord('mascot');\n mascot.changedAttributes(); // {}\n mascot.set('name', 'Tomster');\n mascot.changedAttributes(); // { name: [undefined, 'Tomster'] }\n mascot.set('isAdmin', true);\n mascot.changedAttributes(); // { isAdmin: [undefined, true], name: [undefined, 'Tomster'] }\n mascot.save().then(function() {\n mascot.changedAttributes(); // {}\n mascot.set('isAdmin', false);\n mascot.changedAttributes(); // { isAdmin: [true, false] }\n });\n ```\n @method changedAttributes\n @public\n @return {Object} an object, whose keys are changed properties,\n and value is an [oldProp, newProp] array.\n */\n changedAttributes() {\n return this._internalModel.changedAttributes();\n }\n\n /**\n If the model `hasDirtyAttributes` this function will discard any unsaved\n changes. If the model `isNew` it will be removed from the store.\n Example\n ```javascript\n record.get('name'); // 'Untitled Document'\n record.set('name', 'Doc 1');\n record.get('name'); // 'Doc 1'\n record.rollbackAttributes();\n record.get('name'); // 'Untitled Document'\n ```\n @since 1.13.0\n @method rollbackAttributes\n @public\n */\n rollbackAttributes() {\n this._internalModel.rollbackAttributes();\n this.currentState.cleanErrorRequests();\n }\n\n /**\n @method _createSnapshot\n @private\n */\n _createSnapshot() {\n return this._internalModel.createSnapshot();\n }\n toStringExtension() {\n // the _internalModel guard exists, because some dev-only deprecation code\n // (addListener via validatePropertyInjections) invokes toString before the\n // object is real.\n return this._internalModel && this._internalModel.id;\n }\n\n /**\n Save the record and persist any changes to the record to an\n external source via the adapter.\n Example\n ```javascript\n record.set('name', 'Tomster');\n record.save().then(function() {\n // Success callback\n }, function() {\n // Error callback\n });\n ```\n If you pass an object using the `adapterOptions` property of the options\n argument it will be passed to your adapter via the snapshot.\n ```js\n record.save({ adapterOptions: { subscribe: false } });\n ```\n ```app/adapters/post.js\n import MyCustomAdapter from './custom-adapter';\n export default class PostAdapter extends MyCustomAdapter {\n updateRecord(store, type, snapshot) {\n if (snapshot.adapterOptions.subscribe) {\n // ...\n }\n // ...\n }\n }\n ```\n @method save\n @public\n @param {Object} options\n @return {Promise} a promise that will be resolved when the adapter returns\n successfully or rejected if the adapter returns with an error.\n */\n save(options) {\n const promise = this._internalModel.save(options).then(() => this);\n {\n return Private.deprecatedPromiseObject(Private.PromiseObject.create({\n promise\n }));\n }\n }\n\n /**\n Reload the record from the adapter.\n This will only work if the record has already finished loading.\n Example\n ```app/controllers/model/view.js\n import Controller from '@ember/controller';\n import { action } from '@ember/object';\n export default class ViewController extends Controller {\n @action\n reload() {\n this.model.reload().then(function(model) {\n // do something with the reloaded model\n });\n }\n }\n ```\n @method reload\n @public\n @param {Object} options optional, may include `adapterOptions` hash which will be passed to adapter request\n @return {Promise} a promise that will be resolved with the record when the\n adapter returns successfully or rejected if the adapter returns\n with an error.\n */\n reload(options) {\n let wrappedAdapterOptions;\n if (typeof options === 'object' && options !== null && options.adapterOptions) {\n wrappedAdapterOptions = {\n adapterOptions: options.adapterOptions\n };\n }\n this.isReloading = true;\n return Private.PromiseObject.create({\n promise: this._internalModel.reload(wrappedAdapterOptions).then(() => this).finally(() => {\n this.isReloading = false;\n })\n });\n }\n attr() {\n (debug.assert('The `attr` method is not available on Model, a Snapshot was probably expected. Are you passing a Model instead of a Snapshot to your serializer?', false));\n }\n\n /**\n Get the reference for the specified belongsTo relationship.\n Example\n ```app/models/blog.js\n import Model, { belongsTo } from '@ember-data/model';\n export default class BlogModel extends Model {\n @belongsTo({ async: true }) user;\n }\n ```\n ```javascript\n let blog = store.push({\n data: {\n type: 'blog',\n id: 1,\n relationships: {\n user: {\n data: { type: 'user', id: 1 }\n }\n }\n }\n });\n let userRef = blog.belongsTo('user');\n // check if the user relationship is loaded\n let isLoaded = userRef.value() !== null;\n // get the record of the reference (null if not yet available)\n let user = userRef.value();\n // get the identifier of the reference\n if (userRef.remoteType() === \"id\") {\n let id = userRef.id();\n } else if (userRef.remoteType() === \"link\") {\n let link = userRef.link();\n }\n // load user (via store.findRecord or store.findBelongsTo)\n userRef.load().then(...)\n // or trigger a reload\n userRef.reload().then(...)\n // provide data for reference\n userRef.push({\n type: 'user',\n id: 1,\n attributes: {\n username: \"@user\"\n }\n }).then(function(user) {\n userRef.value() === user;\n });\n ```\n @method belongsTo\n @public\n @param {String} name of the relationship\n @since 2.5.0\n @return {BelongsToReference} reference for this relationship\n */\n belongsTo(name) {\n return this._internalModel.referenceFor('belongsTo', name);\n }\n\n /**\n Get the reference for the specified hasMany relationship.\n Example\n ```app/models/blog.js\n import Model, { hasMany } from '@ember-data/model';\n export default class BlogModel extends Model {\n @hasMany({ async: true }) comments;\n }\n let blog = store.push({\n data: {\n type: 'blog',\n id: 1,\n relationships: {\n comments: {\n data: [\n { type: 'comment', id: 1 },\n { type: 'comment', id: 2 }\n ]\n }\n }\n }\n });\n let commentsRef = blog.hasMany('comments');\n // check if the comments are loaded already\n let isLoaded = commentsRef.value() !== null;\n // get the records of the reference (null if not yet available)\n let comments = commentsRef.value();\n // get the identifier of the reference\n if (commentsRef.remoteType() === \"ids\") {\n let ids = commentsRef.ids();\n } else if (commentsRef.remoteType() === \"link\") {\n let link = commentsRef.link();\n }\n // load comments (via store.findMany or store.findHasMany)\n commentsRef.load().then(...)\n // or trigger a reload\n commentsRef.reload().then(...)\n // provide data for reference\n commentsRef.push([{ type: 'comment', id: 1 }, { type: 'comment', id: 2 }]).then(function(comments) {\n commentsRef.value() === comments;\n });\n ```\n @method hasMany\n @public\n @param {String} name of the relationship\n @since 2.5.0\n @return {HasManyReference} reference for this relationship\n */\n hasMany(name) {\n return this._internalModel.referenceFor('hasMany', name);\n }\n\n /**\n Given a callback, iterates over each of the relationships in the model,\n invoking the callback with the name of each relationship and its relationship\n descriptor.\n The callback method you provide should have the following signature (all\n parameters are optional):\n ```javascript\n function(name, descriptor);\n ```\n - `name` the name of the current property in the iteration\n - `descriptor` the meta object that describes this relationship\n The relationship descriptor argument is an object with the following properties.\n - **key** String the name of this relationship on the Model\n - **kind** String \"hasMany\" or \"belongsTo\"\n - **options** Object the original options hash passed when the relationship was declared\n - **parentType** Model the type of the Model that owns this relationship\n - **type** String the type name of the related Model\n Note that in addition to a callback, you can also pass an optional target\n object that will be set as `this` on the context.\n Example\n ```app/serializers/application.js\n import JSONSerializer from '@ember-data/serializer/json';\n export default class ApplicationSerializer extends JSONSerializer {\n serialize(record, options) {\n let json = {};\n record.eachRelationship(function(name, descriptor) {\n if (descriptor.kind === 'hasMany') {\n let serializedHasManyName = name.toUpperCase() + '_IDS';\n json[serializedHasManyName] = record.get(name).mapBy('id');\n }\n });\n return json;\n }\n }\n ```\n @method eachRelationship\n @public\n @param {Function} callback the callback to invoke\n @param {any} binding the value to which the callback's `this` should be bound\n */\n eachRelationship(callback, binding) {\n this.constructor.eachRelationship(callback, binding);\n }\n relationshipFor(name) {\n return this.constructor.relationshipsByName.get(name);\n }\n inverseFor(key) {\n return this.constructor.inverseFor(key, this._internalModel.store);\n }\n eachAttribute(callback, binding) {\n this.constructor.eachAttribute(callback, binding);\n }\n /*\n These class methods below provide relationship\n introspection abilities about relationships.\n A note about the computed properties contained here:\n **These properties are effectively sealed once called for the first time.**\n To avoid repeatedly doing expensive iteration over a model's fields, these\n values are computed once and then cached for the remainder of the runtime of\n your application.\n If your application needs to modify a class after its initial definition\n (for example, using `reopen()` to add additional attributes), make sure you\n do it before using your model with the store, which uses these properties\n extensively.\n */\n\n /**\n For a given relationship name, returns the model type of the relationship.\n For example, if you define a model like this:\n ```app/models/post.js\n import Model, { hasMany } from '@ember-data/model';\n export default class PostModel extends Model {\n @hasMany('comment') comments;\n }\n ```\n Calling `store.modelFor('post').typeForRelationship('comments', store)` will return `Comment`.\n @method typeForRelationship\n @public\n @static\n @param {String} name the name of the relationship\n @param {store} store an instance of Store\n @return {Model} the type of the relationship, or undefined\n */\n static typeForRelationship(name, store) {\n let relationship = this.relationshipsByName.get(name);\n return relationship && store.modelFor(relationship.type);\n }\n static get inverseMap() {\n return Object.create(null);\n }\n\n /**\n Find the relationship which is the inverse of the one asked for.\n For example, if you define models like this:\n ```app/models/post.js\n import Model, { hasMany } from '@ember-data/model';\n export default class PostModel extends Model {\n @hasMany('message') comments;\n }\n ```\n ```app/models/message.js\n import Model from '@ember-data/model';\n import { belongsTo } from '@ember-decorators/data';\n export default class MessageModel extends Model {\n @belongsTo('post') owner;\n }\n ```\n ``` js\n store.modelFor('post').inverseFor('comments', store) // { type: App.Message, name: 'owner', kind: 'belongsTo' }\n store.modelFor('message').inverseFor('owner', store) // { type: App.Post, name: 'comments', kind: 'hasMany' }\n ```\n @method inverseFor\n @public\n @static\n @param {String} name the name of the relationship\n @param {Store} store\n @return {Object} the inverse relationship, or null\n */\n static inverseFor(name, store) {\n let inverseMap = this.inverseMap;\n if (inverseMap[name]) {\n return inverseMap[name];\n } else {\n let inverse = this._findInverseFor(name, store);\n inverseMap[name] = inverse;\n return inverse;\n }\n }\n\n //Calculate the inverse, ignoring the cache\n static _findInverseFor(name, store) {\n let inverseType = this.typeForRelationship(name, store);\n if (!inverseType) {\n return null;\n }\n let propertyMeta = this.metaForProperty(name);\n //If inverse is manually specified to be null, like `comments: hasMany('message', { inverse: null })`\n let options = propertyMeta.options;\n if (options.inverse === null) {\n return null;\n }\n let inverseName, inverseKind, inverse, inverseOptions;\n\n //If inverse is specified manually, return the inverse\n if (options.inverse) {\n inverseName = options.inverse;\n inverse = inverseType.relationshipsByName.get(inverseName);\n (!(!utils.isNone(inverse)) && debug.assert(\"We found no inverse relationships by the name of '\" + inverseName + \"' on the '\" + inverseType.modelName + \"' model. This is most likely due to a missing attribute on your model definition.\", !utils.isNone(inverse))); // TODO probably just return the whole inverse here\n inverseKind = inverse.kind;\n inverseOptions = inverse.options;\n } else {\n //No inverse was specified manually, we need to use a heuristic to guess one\n if (propertyMeta.type === propertyMeta.parentModelName) {\n (debug.warn(`Detected a reflexive relationship by the name of '${name}' without an inverse option. Look at https://guides.emberjs.com/current/models/relationships/#toc_reflexive-relations for how to explicitly specify inverses.`, false, {\n id: 'ds.model.reflexive-relationship-without-inverse'\n }));\n }\n let possibleRelationships = findPossibleInverses(this, inverseType, name);\n if (possibleRelationships.length === 0) {\n return null;\n }\n let filteredRelationships = possibleRelationships.filter(possibleRelationship => {\n let optionsForRelationship = inverseType.metaForProperty(possibleRelationship.name).options;\n return name === optionsForRelationship.inverse;\n });\n (!(filteredRelationships.length < 2) && debug.assert(\"You defined the '\" + name + \"' relationship on \" + this + ', but you defined the inverse relationships of type ' + inverseType.toString() + ' multiple times. Look at https://guides.emberjs.com/current/models/relationships/#toc_explicit-inverses for how to explicitly specify inverses', filteredRelationships.length < 2));\n if (filteredRelationships.length === 1) {\n possibleRelationships = filteredRelationships;\n }\n (!(possibleRelationships.length === 1) && debug.assert(\"You defined the '\" + name + \"' relationship on \" + this + ', but multiple possible inverse relationships of type ' + this + ' were found on ' + inverseType + '. Look at https://guides.emberjs.com/current/models/relationships/#toc_explicit-inverses for how to explicitly specify inverses', possibleRelationships.length === 1));\n inverseName = possibleRelationships[0].name;\n inverseKind = possibleRelationships[0].kind;\n inverseOptions = possibleRelationships[0].options;\n }\n (!(!inverseOptions || inverseOptions.inverse !== null) && debug.assert(`The ${inverseType.modelName}:${inverseName} relationship declares 'inverse: null', but it was resolved as the inverse for ${this.modelName}:${name}.`, !inverseOptions || inverseOptions.inverse !== null));\n return {\n type: inverseType,\n name: inverseName,\n kind: inverseKind,\n options: inverseOptions\n };\n }\n\n /**\n The model's relationships as a map, keyed on the type of the\n relationship. The value of each entry is an array containing a descriptor\n for each relationship with that type, describing the name of the relationship\n as well as the type.\n For example, given the following model definition:\n ```app/models/blog.js\n import Model, { belongsTo, hasMany } from '@ember-data/model';\n export default class BlogModel extends Model {\n @hasMany('user') users;\n @belongsTo('user') owner;\n @hasMany('post') posts;\n }\n ```\n This computed property would return a map describing these\n relationships, like this:\n ```javascript\n import { get } from '@ember/object';\n import Blog from 'app/models/blog';\n import User from 'app/models/user';\n import Post from 'app/models/post';\n let relationships = Blog.relationships;\n relationships.get('user');\n //=> [ { name: 'users', kind: 'hasMany' },\n // { name: 'owner', kind: 'belongsTo' } ]\n relationships.get('post');\n //=> [ { name: 'posts', kind: 'hasMany' } ]\n ```\n @property relationships\n @public\n @static\n @type Map\n @readOnly\n */\n\n static get relationships() {\n let map = new Map();\n let relationshipsByName = this.relationshipsByName;\n\n // Loop through each computed property on the class\n relationshipsByName.forEach(desc => {\n let {\n type\n } = desc;\n if (!map.has(type)) {\n map.set(type, []);\n }\n map.get(type).push(desc);\n });\n return map;\n }\n\n /**\n A hash containing lists of the model's relationships, grouped\n by the relationship kind. For example, given a model with this\n definition:\n ```app/models/blog.js\n import Model, { belongsTo, hasMany } from '@ember-data/model';\n export default class BlogModel extends Model {\n @hasMany('user') users;\n @belongsTo('user') owner;\n @hasMany('post') posts;\n }\n ```\n This property would contain the following:\n ```javascript\n import { get } from '@ember/object';\n import Blog from 'app/models/blog';\n let relationshipNames = Blog.relationshipNames;\n relationshipNames.hasMany;\n //=> ['users', 'posts']\n relationshipNames.belongsTo;\n //=> ['owner']\n ```\n @property relationshipNames\n @public\n @static\n @type Object\n @readOnly\n */\n static get relationshipNames() {\n let names = {\n hasMany: [],\n belongsTo: []\n };\n this.eachComputedProperty((name, meta) => {\n if (meta.isRelationship) {\n names[meta.kind].push(name);\n }\n });\n return names;\n }\n\n /**\n An array of types directly related to a model. Each type will be\n included once, regardless of the number of relationships it has with\n the model.\n For example, given a model with this definition:\n ```app/models/blog.js\n import Model, { belongsTo, hasMany } from '@ember-data/model';\n export default class BlogModel extends Model {\n @hasMany('user') users;\n @belongsTo('user') owner;\n @hasMany('post') posts;\n }\n ```\n This property would contain the following:\n ```javascript\n import { get } from '@ember/object';\n import Blog from 'app/models/blog';\n let relatedTypes = Blog.relatedTypes');\n //=> [ User, Post ]\n ```\n @property relatedTypes\n @public\n @static\n @type Ember.Array\n @readOnly\n */\n static get relatedTypes() {\n let types = [];\n let rels = this.relationshipsObject;\n let relationships = Object.keys(rels);\n\n // create an array of the unique types involved\n // in relationships\n for (let i = 0; i < relationships.length; i++) {\n let name = relationships[i];\n let meta = rels[name];\n let modelName = meta.type;\n if (types.indexOf(modelName) === -1) {\n types.push(modelName);\n }\n }\n return types;\n }\n\n /**\n A map whose keys are the relationships of a model and whose values are\n relationship descriptors.\n For example, given a model with this\n definition:\n ```app/models/blog.js\n import Model, { belongsTo, hasMany } from '@ember-data/model';\n export default class BlogModel extends Model {\n @hasMany('user') users;\n @belongsTo('user') owner;\n @hasMany('post') posts;\n }\n ```\n This property would contain the following:\n ```javascript\n import { get } from '@ember/object';\n import Blog from 'app/models/blog';\n let relationshipsByName = Blog.relationshipsByName;\n relationshipsByName.get('users');\n //=> { key: 'users', kind: 'hasMany', type: 'user', options: Object, isRelationship: true }\n relationshipsByName.get('owner');\n //=> { key: 'owner', kind: 'belongsTo', type: 'user', options: Object, isRelationship: true }\n ```\n @property relationshipsByName\n @public\n @static\n @type Map\n @readOnly\n */\n static get relationshipsByName() {\n let map = new Map();\n let rels = this.relationshipsObject;\n let relationships = Object.keys(rels);\n for (let i = 0; i < relationships.length; i++) {\n let key = relationships[i];\n let value = rels[key];\n map.set(value.key, value);\n }\n return map;\n }\n static get relationshipsObject() {\n let relationships = Object.create(null);\n let modelName = this.modelName;\n this.eachComputedProperty((name, meta) => {\n if (meta.isRelationship) {\n meta.key = name;\n meta.name = name;\n meta.parentModelName = modelName;\n relationships[name] = relationshipFromMeta(meta);\n }\n });\n return relationships;\n }\n\n /**\n A map whose keys are the fields of the model and whose values are strings\n describing the kind of the field. A model's fields are the union of all of its\n attributes and relationships.\n For example:\n ```app/models/blog.js\n import Model, { attr, belongsTo, hasMany } from '@ember-data/model';\n export default class BlogModel extends Model {\n @hasMany('user') users;\n @belongsTo('user') owner;\n @hasMany('post') posts;\n @attr('string') title;\n }\n ```\n ```js\n import { get } from '@ember/object';\n import Blog from 'app/models/blog'\n let fields = Blog.fields;\n fields.forEach(function(kind, field) {\n console.log(field, kind);\n });\n // prints:\n // users, hasMany\n // owner, belongsTo\n // posts, hasMany\n // title, attribute\n ```\n @property fields\n @public\n @static\n @type Map\n @readOnly\n */\n static get fields() {\n let map = new Map();\n this.eachComputedProperty((name, meta) => {\n if (meta.isRelationship) {\n map.set(name, meta.kind);\n } else if (meta.isAttribute) {\n map.set(name, 'attribute');\n }\n });\n return map;\n }\n\n /**\n Given a callback, iterates over each of the relationships in the model,\n invoking the callback with the name of each relationship and its relationship\n descriptor.\n @method eachRelationship\n @public\n @static\n @param {Function} callback the callback to invoke\n @param {any} binding the value to which the callback's `this` should be bound\n */\n static eachRelationship(callback, binding) {\n this.relationshipsByName.forEach((relationship, name) => {\n callback.call(binding, name, relationship);\n });\n }\n\n /**\n Given a callback, iterates over each of the types related to a model,\n invoking the callback with the related type's class. Each type will be\n returned just once, regardless of how many different relationships it has\n with a model.\n @method eachRelatedType\n @public\n @static\n @param {Function} callback the callback to invoke\n @param {any} binding the value to which the callback's `this` should be bound\n */\n static eachRelatedType(callback, binding) {\n let relationshipTypes = this.relatedTypes;\n for (let i = 0; i < relationshipTypes.length; i++) {\n let type = relationshipTypes[i];\n callback.call(binding, type);\n }\n }\n static determineRelationshipType(knownSide, store) {\n let knownKey = knownSide.key;\n let knownKind = knownSide.kind;\n let inverse = this.inverseFor(knownKey, store);\n // let key;\n let otherKind;\n if (!inverse) {\n return knownKind === 'belongsTo' ? 'oneToNone' : 'manyToNone';\n }\n\n // key = inverse.name;\n otherKind = inverse.kind;\n if (otherKind === 'belongsTo') {\n return knownKind === 'belongsTo' ? 'oneToOne' : 'manyToOne';\n } else {\n return knownKind === 'belongsTo' ? 'oneToMany' : 'manyToMany';\n }\n }\n\n /**\n A map whose keys are the attributes of the model (properties\n described by attr) and whose values are the meta object for the\n property.\n Example\n ```app/models/person.js\n import Model, { attr } from '@ember-data/model';\n export default class PersonModel extends Model {\n @attr('string') firstName;\n @attr('string') lastName;\n @attr('date') birthday;\n }\n ```\n ```javascript\n import { get } from '@ember/object';\n import Person from 'app/models/person'\n let attributes = Person.attributes\n attributes.forEach(function(meta, name) {\n console.log(name, meta);\n });\n // prints:\n // firstName {type: \"string\", isAttribute: true, options: Object, parentType: function, name: \"firstName\"}\n // lastName {type: \"string\", isAttribute: true, options: Object, parentType: function, name: \"lastName\"}\n // birthday {type: \"date\", isAttribute: true, options: Object, parentType: function, name: \"birthday\"}\n ```\n @property attributes\n @public\n @static\n @type {Map}\n @readOnly\n */\n static get attributes() {\n let map = new Map();\n this.eachComputedProperty((name, meta) => {\n if (meta.isAttribute) {\n (!(name !== 'id') && debug.assert(\"You may not set `id` as an attribute on your model. Please remove any lines that look like: `id: attr('')` from \" + this.toString(), name !== 'id'));\n meta.name = name;\n map.set(name, meta);\n }\n });\n return map;\n }\n\n /**\n A map whose keys are the attributes of the model (properties\n described by attr) and whose values are type of transformation\n applied to each attribute. This map does not include any\n attributes that do not have an transformation type.\n Example\n ```app/models/person.js\n import Model, { attr } from '@ember-data/model';\n export default class PersonModel extends Model {\n @attr firstName;\n @attr('string') lastName;\n @attr('date') birthday;\n }\n ```\n ```javascript\n import { get } from '@ember/object';\n import Person from 'app/models/person';\n let transformedAttributes = Person.transformedAttributes\n transformedAttributes.forEach(function(field, type) {\n console.log(field, type);\n });\n // prints:\n // lastName string\n // birthday date\n ```\n @property transformedAttributes\n @public\n @static\n @type {Map}\n @readOnly\n */\n static get transformedAttributes() {\n let map = new Map();\n this.eachAttribute((key, meta) => {\n if (meta.type) {\n map.set(key, meta.type);\n }\n });\n return map;\n }\n\n /**\n Iterates through the attributes of the model, calling the passed function on each\n attribute.\n The callback method you provide should have the following signature (all\n parameters are optional):\n ```javascript\n function(name, meta);\n ```\n - `name` the name of the current property in the iteration\n - `meta` the meta object for the attribute property in the iteration\n Note that in addition to a callback, you can also pass an optional target\n object that will be set as `this` on the context.\n Example\n ```javascript\n import Model, { attr } from '@ember-data/model';\n class PersonModel extends Model {\n @attr('string') firstName;\n @attr('string') lastName;\n @attr('date') birthday;\n }\n PersonModel.eachAttribute(function(name, meta) {\n console.log(name, meta);\n });\n // prints:\n // firstName {type: \"string\", isAttribute: true, options: Object, parentType: function, name: \"firstName\"}\n // lastName {type: \"string\", isAttribute: true, options: Object, parentType: function, name: \"lastName\"}\n // birthday {type: \"date\", isAttribute: true, options: Object, parentType: function, name: \"birthday\"}\n ```\n @method eachAttribute\n @public\n @param {Function} callback The callback to execute\n @param {Object} [binding] the value to which the callback's `this` should be bound\n @static\n */\n static eachAttribute(callback, binding) {\n this.attributes.forEach((meta, name) => {\n callback.call(binding, name, meta);\n });\n }\n\n /**\n Iterates through the transformedAttributes of the model, calling\n the passed function on each attribute. Note the callback will not be\n called for any attributes that do not have an transformation type.\n The callback method you provide should have the following signature (all\n parameters are optional):\n ```javascript\n function(name, type);\n ```\n - `name` the name of the current property in the iteration\n - `type` a string containing the name of the type of transformed\n applied to the attribute\n Note that in addition to a callback, you can also pass an optional target\n object that will be set as `this` on the context.\n Example\n ```javascript\n import Model, { attr } from '@ember-data/model';\n let Person = Model.extend({\n firstName: attr(),\n lastName: attr('string'),\n birthday: attr('date')\n });\n Person.eachTransformedAttribute(function(name, type) {\n console.log(name, type);\n });\n // prints:\n // lastName string\n // birthday date\n ```\n @method eachTransformedAttribute\n @public\n @param {Function} callback The callback to execute\n @param {Object} [binding] the value to which the callback's `this` should be bound\n @static\n */\n static eachTransformedAttribute(callback, binding) {\n this.transformedAttributes.forEach((type, name) => {\n callback.call(binding, name, type);\n });\n }\n\n /**\n Returns the name of the model class.\n @method toString\n @public\n @static\n */\n static toString() {\n return `model:${EmberObject.get(this, 'modelName')}`;\n }\n }, _Model.isModel = true, _Model.modelName = null, _Model), _applyDecoratedDescriptor$1(_class$1.prototype, \"isEmpty\", [compat.dependentKeyCompat], Object.getOwnPropertyDescriptor(_class$1.prototype, \"isEmpty\"), _class$1.prototype), _applyDecoratedDescriptor$1(_class$1.prototype, \"isLoading\", [compat.dependentKeyCompat], Object.getOwnPropertyDescriptor(_class$1.prototype, \"isLoading\"), _class$1.prototype), _applyDecoratedDescriptor$1(_class$1.prototype, \"isLoaded\", [compat.dependentKeyCompat], Object.getOwnPropertyDescriptor(_class$1.prototype, \"isLoaded\"), _class$1.prototype), _applyDecoratedDescriptor$1(_class$1.prototype, \"hasDirtyAttributes\", [compat.dependentKeyCompat], Object.getOwnPropertyDescriptor(_class$1.prototype, \"hasDirtyAttributes\"), _class$1.prototype), _applyDecoratedDescriptor$1(_class$1.prototype, \"isSaving\", [compat.dependentKeyCompat], Object.getOwnPropertyDescriptor(_class$1.prototype, \"isSaving\"), _class$1.prototype), _applyDecoratedDescriptor$1(_class$1.prototype, \"isDeleted\", [compat.dependentKeyCompat], Object.getOwnPropertyDescriptor(_class$1.prototype, \"isDeleted\"), _class$1.prototype), _applyDecoratedDescriptor$1(_class$1.prototype, \"isNew\", [compat.dependentKeyCompat], Object.getOwnPropertyDescriptor(_class$1.prototype, \"isNew\"), _class$1.prototype), _applyDecoratedDescriptor$1(_class$1.prototype, \"isValid\", [compat.dependentKeyCompat], Object.getOwnPropertyDescriptor(_class$1.prototype, \"isValid\"), _class$1.prototype), _applyDecoratedDescriptor$1(_class$1.prototype, \"dirtyType\", [compat.dependentKeyCompat], Object.getOwnPropertyDescriptor(_class$1.prototype, \"dirtyType\"), _class$1.prototype), _applyDecoratedDescriptor$1(_class$1.prototype, \"isError\", [compat.dependentKeyCompat], Object.getOwnPropertyDescriptor(_class$1.prototype, \"isError\"), _class$1.prototype), _descriptor$1 = _applyDecoratedDescriptor$1(_class$1.prototype, \"isReloading\", [tracking.tracked], {\n configurable: true,\n enumerable: true,\n writable: true,\n initializer: function () {\n return false;\n }\n }), _applyDecoratedDescriptor$1(_class$1.prototype, \"id\", [tagged], Object.getOwnPropertyDescriptor(_class$1.prototype, \"id\"), _class$1.prototype), _applyDecoratedDescriptor$1(_class$1.prototype, \"currentState\", [tagged], Object.getOwnPropertyDescriptor(_class$1.prototype, \"currentState\"), _class$1.prototype), _applyDecoratedDescriptor$1(_class$1.prototype, \"errors\", [computeOnce], Object.getOwnPropertyDescriptor(_class$1.prototype, \"errors\"), _class$1.prototype), _applyDecoratedDescriptor$1(_class$1.prototype, \"adapterError\", [compat.dependentKeyCompat], Object.getOwnPropertyDescriptor(_class$1.prototype, \"adapterError\"), _class$1.prototype), _applyDecoratedDescriptor$1(_class$1, \"inverseMap\", [computeOnce], Object.getOwnPropertyDescriptor(_class$1, \"inverseMap\"), _class$1), _applyDecoratedDescriptor$1(_class$1, \"relationships\", [computeOnce], Object.getOwnPropertyDescriptor(_class$1, \"relationships\"), _class$1), _applyDecoratedDescriptor$1(_class$1, \"relationshipNames\", [computeOnce], Object.getOwnPropertyDescriptor(_class$1, \"relationshipNames\"), _class$1), _applyDecoratedDescriptor$1(_class$1, \"relatedTypes\", [computeOnce], Object.getOwnPropertyDescriptor(_class$1, \"relatedTypes\"), _class$1), _applyDecoratedDescriptor$1(_class$1, \"relationshipsByName\", [computeOnce], Object.getOwnPropertyDescriptor(_class$1, \"relationshipsByName\"), _class$1), _applyDecoratedDescriptor$1(_class$1, \"relationshipsObject\", [computeOnce], Object.getOwnPropertyDescriptor(_class$1, \"relationshipsObject\"), _class$1), _applyDecoratedDescriptor$1(_class$1, \"fields\", [computeOnce], Object.getOwnPropertyDescriptor(_class$1, \"fields\"), _class$1), _applyDecoratedDescriptor$1(_class$1, \"attributes\", [computeOnce], Object.getOwnPropertyDescriptor(_class$1, \"attributes\"), _class$1), _applyDecoratedDescriptor$1(_class$1, \"transformedAttributes\", [computeOnce], Object.getOwnPropertyDescriptor(_class$1, \"transformedAttributes\"), _class$1), _class$1); // this is required to prevent `init` from passing\n // the values initialized during create to `setUnknownProperty`\n Model.prototype._internalModel = null;\n Model.prototype.store = null;\n Model.prototype._createProps = null;\n {\n /**\n Provides info about the model for debugging purposes\n by grouping the properties into more semantic groups.\n Meant to be used by debugging tools such as the Chrome Ember Extension.\n - Groups all attributes in \"Attributes\" group.\n - Groups all belongsTo relationships in \"Belongs To\" group.\n - Groups all hasMany relationships in \"Has Many\" group.\n - Groups all flags in \"Flags\" group.\n - Flags relationship CPs as expensive properties.\n @method _debugInfo\n @for Model\n @private\n */\n Model.prototype._debugInfo = function () {\n let attributes = ['id'];\n let relationships = {};\n let expensiveProperties = [];\n this.eachAttribute((name, meta) => attributes.push(name));\n let groups = [{\n name: 'Attributes',\n properties: attributes,\n expand: true\n }];\n this.eachRelationship((name, relationship) => {\n let properties = relationships[relationship.kind];\n if (properties === undefined) {\n properties = relationships[relationship.kind] = [];\n groups.push({\n name: relationship.kind,\n properties,\n expand: true\n });\n }\n properties.push(name);\n expensiveProperties.push(name);\n });\n groups.push({\n name: 'Flags',\n properties: ['isLoaded', 'hasDirtyAttributes', 'isSaving', 'isDeleted', 'isError', 'isNew', 'isValid']\n });\n return {\n propertyInfo: {\n // include all other mixins / properties (not just the grouped ones)\n includeOtherProperties: true,\n groups: groups,\n // don't pre-calculate unless cached\n expensiveProperties: expensiveProperties\n }\n };\n };\n }\n {\n let lookupDescriptor = function lookupDescriptor(obj, keyName) {\n let current = obj;\n do {\n let descriptor = Object.getOwnPropertyDescriptor(current, keyName);\n if (descriptor !== undefined) {\n return descriptor;\n }\n current = Object.getPrototypeOf(current);\n } while (current !== null);\n return null;\n };\n let isBasicDesc = function isBasicDesc(desc) {\n return !desc || !desc.get && !desc.set && desc.enumerable === true && desc.writable === true && desc.configurable === true;\n };\n let isDefaultEmptyDescriptor = function isDefaultEmptyDescriptor(obj, keyName) {\n let instanceDesc = lookupDescriptor(obj, keyName);\n return isBasicDesc(instanceDesc) && lookupDescriptor(obj.constructor, keyName) === null;\n };\n Model.reopen({\n init() {\n this._super(...arguments);\n if (!isDefaultEmptyDescriptor(this, '_internalModel') || !(this._internalModel instanceof Private.InternalModel)) {\n throw new Error(`'_internalModel' is a reserved property name on instances of classes extending Model. Please choose a different property name for ${this.constructor.toString()}`);\n }\n let ourDescriptor = lookupDescriptor(Model.prototype, 'currentState');\n let theirDescriptor = lookupDescriptor(this, 'currentState');\n let realState = this.___recordState || this._internalModel.currentState;\n if (ourDescriptor.get !== theirDescriptor.get || realState !== this.currentState) {\n throw new Error(`'currentState' is a reserved property name on instances of classes extending Model. Please choose a different property name for ${this.constructor.toString()}`);\n }\n const ID_DESCRIPTOR = lookupDescriptor(Model.prototype, 'id');\n let idDesc = lookupDescriptor(this, 'id');\n if (idDesc.get !== ID_DESCRIPTOR.get) {\n throw new EmberError__default[\"default\"](`You may not set 'id' as an attribute on your model. Please remove any lines that look like: \\`id: attr('')\\` from ${this.constructor.toString()}`);\n }\n }\n });\n }\n\n /**\n @module @ember-data/model\n */\n\n /**\n @method diffArray\n @internal\n @param {Array} oldArray the old array\n @param {Array} newArray the new array\n @return {hash} {\n firstChangeIndex: , // null if no change\n addedCount: , // 0 if no change\n removedCount: // 0 if no change\n }\n */\n function diffArray(oldArray, newArray) {\n const oldLength = oldArray.length;\n const newLength = newArray.length;\n const shortestLength = Math.min(oldLength, newLength);\n let firstChangeIndex = null; // null signifies no changes\n\n // find the first change\n for (let i = 0; i < shortestLength; i++) {\n // compare each item in the array\n if (oldArray[i] !== newArray[i]) {\n firstChangeIndex = i;\n break;\n }\n }\n if (firstChangeIndex === null && newLength !== oldLength) {\n // no change found in the overlapping block\n // and array lengths differ,\n // so change starts at end of overlap\n firstChangeIndex = shortestLength;\n }\n let addedCount = 0;\n let removedCount = 0;\n if (firstChangeIndex !== null) {\n // we found a change, find the end of the change\n let unchangedEndBlockLength = shortestLength - firstChangeIndex;\n // walk back from the end of both arrays until we find a change\n for (let i = 1; i <= shortestLength; i++) {\n // compare each item in the array\n if (oldArray[oldLength - i] !== newArray[newLength - i]) {\n unchangedEndBlockLength = i - 1;\n break;\n }\n }\n addedCount = newLength - unchangedEndBlockLength - firstChangeIndex;\n removedCount = oldLength - unchangedEndBlockLength - firstChangeIndex;\n }\n return {\n firstChangeIndex,\n addedCount,\n removedCount\n };\n }\n\n /**\n A `ManyArray` is a `MutableArray` that represents the contents of a has-many\n relationship.\n\n The `ManyArray` is instantiated lazily the first time the relationship is\n requested.\n\n This class is not intended to be directly instantiated by consuming applications.\n\n ### Inverses\n\n Often, the relationships in Ember Data applications will have\n an inverse. For example, imagine the following models are\n defined:\n\n ```app/models/post.js\n import Model, { hasMany } from '@ember-data/model';\n\n export default class PostModel extends Model {\n @hasMany('comment') comments;\n }\n ```\n\n ```app/models/comment.js\n import Model, { belongsTo } from '@ember-data/model';\n\n export default class CommentModel extends Model {\n @belongsTo('post') post;\n }\n ```\n\n If you created a new instance of `Post` and added\n a `Comment` record to its `comments` has-many\n relationship, you would expect the comment's `post`\n property to be set to the post that contained\n the has-many.\n\n We call the record to which a relationship belongs-to the\n relationship's _owner_.\n\n @class ManyArray\n @public\n @extends Ember.EmberObject\n @uses Ember.MutableArray\n */\n var manyArray = EmberObject__default[\"default\"].extend(MutableArray__default[\"default\"], {\n isAsync: false,\n isLoaded: false,\n init() {\n this._super(...arguments);\n\n /**\n The loading state of this array\n @property {Boolean} isLoaded\n @public\n */\n this.isLoaded = this.isLoaded || false;\n this._length = 0;\n\n /**\n Metadata associated with the request for async hasMany relationships.\n Example\n Given that the server returns the following JSON payload when fetching a\n hasMany relationship:\n ```js\n {\n \"comments\": [{\n \"id\": 1,\n \"comment\": \"This is the first comment\",\n }, {\n // ...\n }],\n \"meta\": {\n \"page\": 1,\n \"total\": 5\n }\n }\n ```\n You can then access the meta data via the `meta` property:\n ```js\n let comments = await post.comments;\n let meta = comments.meta;\n // meta.page => 1\n // meta.total => 5\n ```\n @property {Object | null} meta\n @public\n */\n this._meta = this._meta || null;\n\n /**\n * Retrieve the links for this relationship\n *\n @property {Object | null} links\n @public\n */\n this._links = this._links || null;\n\n /**\n `true` if the relationship is polymorphic, `false` otherwise.\n @property {Boolean} isPolymorphic\n @private\n */\n this.isPolymorphic = this.isPolymorphic || false;\n\n /**\n The relationship which manages this array.\n @property {ManyRelationship} relationship\n @private\n */\n this.currentState = [];\n this._isUpdating = false;\n this._isDirty = false;\n /*\n * Unfortunately ArrayProxy adds it's observers lazily,\n * so in a first-render situation we may sometimes notify\n * prior to the ArrayProxy having installed it's observers\n * (which occurs during _revalidate()).\n *\n * This leads to the flush occuring on access, the flush takes\n * the hasObservers codepath which in code out of our control\n * notifies again leading to a glimmer rendering invalidation error.\n *\n * We use this flag to detect the case where we notified without\n * array observers but observers were installed prior to flush.\n *\n * We do not need to fire array observers at all in this case\n * since it will be the first-access for those observers.\n */\n this._hasNotified = false;\n // make sure we initialize to the correct state\n // since the user has already accessed\n this.retrieveLatest();\n },\n // TODO refactor away _hasArrayObservers for tests\n get _hasArrayObservers() {\n return this.hasArrayObservers || this.__hasArrayObservers;\n },\n notify() {\n this._isDirty = true;\n if (this._hasArrayObservers && !this._hasNotified) {\n this.retrieveLatest();\n } else {\n this._hasNotified = true;\n this.notifyPropertyChange('[]');\n this.notifyPropertyChange('length');\n this.notifyPropertyChange('firstObject');\n this.notifyPropertyChange('lastObject');\n }\n },\n get length() {\n if (this._isDirty) {\n this.retrieveLatest();\n }\n // By using `get()`, the tracking system knows to pay attention to changes that occur.\n EmberObject.get(this, '[]');\n return this._length;\n },\n set length(value) {\n this._length = value;\n },\n get links() {\n EmberObject.get(this, '[]');\n if (this._isDirty) {\n this.retrieveLatest();\n }\n return this._links;\n },\n set links(v) {\n this._links = v;\n },\n get meta() {\n EmberObject.get(this, '[]');\n if (this._isDirty) {\n this.retrieveLatest();\n }\n return this._meta;\n },\n set meta(v) {\n this._meta = v;\n },\n objectAt(index) {\n if (this._isDirty) {\n this.retrieveLatest();\n }\n let internalModel = this.currentState[index];\n if (internalModel === undefined) {\n return;\n }\n return internalModel.getRecord();\n },\n replace(idx, amt, objects) {\n (!(!this._isUpdating) && debug.assert(`Cannot push mutations to the cache while updating the relationship from cache`, !this._isUpdating));\n this.store._backburner.join(() => {\n let internalModels;\n if (amt > 0) {\n internalModels = this.currentState.slice(idx, idx + amt);\n this.recordData.removeFromHasMany(this.key, internalModels.map(im => Private.recordDataFor(im)));\n }\n if (objects) {\n (!(Array.isArray(objects) || EmberArray__default[\"default\"].detect(objects)) && debug.assert('The third argument to replace needs to be an array.', Array.isArray(objects) || EmberArray__default[\"default\"].detect(objects)));\n this.recordData.addToHasMany(this.key, objects.map(obj => Private.recordDataFor(obj)), idx);\n }\n this.notify();\n });\n },\n retrieveLatest() {\n // It’s possible the parent side of the relationship may have been destroyed by this point\n if (this.isDestroyed || this.isDestroying || this._isUpdating) {\n return;\n }\n this._isDirty = false;\n this._isUpdating = true;\n let jsonApi = this.recordData.getHasMany(this.key);\n let internalModels = [];\n if (jsonApi.data) {\n for (let i = 0; i < jsonApi.data.length; i++) {\n let im = this.store._internalModelForResource(jsonApi.data[i]);\n let shouldRemove = im._isDematerializing || im.currentState.isEmpty || !im.currentState.isLoaded;\n if (!shouldRemove) {\n internalModels.push(im);\n }\n }\n }\n if (jsonApi.meta) {\n this._meta = jsonApi.meta;\n }\n if (jsonApi.links) {\n this._links = jsonApi.links;\n }\n if (this._hasArrayObservers && !this._hasNotified) {\n // diff to find changes\n let diff = diffArray(this.currentState, internalModels);\n // it's null if no change found\n if (diff.firstChangeIndex !== null) {\n // we found a change\n this.arrayContentWillChange(diff.firstChangeIndex, diff.removedCount, diff.addedCount);\n this._length = internalModels.length;\n this.currentState = internalModels;\n this.arrayContentDidChange(diff.firstChangeIndex, diff.removedCount, diff.addedCount);\n }\n } else {\n this._hasNotified = false;\n this._length = internalModels.length;\n this.currentState = internalModels;\n }\n this._isUpdating = false;\n },\n /**\n Reloads all of the records in the manyArray. If the manyArray\n holds a relationship that was originally fetched using a links url\n Ember Data will revisit the original links url to repopulate the\n relationship.\n If the manyArray holds the result of a `store.query()` reload will\n re-run the original query.\n Example\n ```javascript\n let user = store.peekRecord('user', '1')\n await login(user);\n let permissions = await user.permissions;\n await permissions.reload();\n ```\n @method reload\n @public\n */\n reload(options) {\n // TODO this is odd, we don't ask the store for anything else like this?\n return this.store.reloadManyArray(this, this.internalModel, this.key, options);\n },\n /**\n Saves all of the records in the `ManyArray`.\n Example\n ```javascript\n let inbox = await store.findRecord('inbox', '1');\n let messages = await inbox.messages;\n messages.forEach((message) => {\n message.isRead = true;\n });\n messages.save();\n ```\n @method save\n @public\n @return {PromiseArray} promise\n */\n save() {\n let manyArray = this;\n let promiseLabel = 'DS: ManyArray#save ' + this.type;\n let promise = rsvp.all(this.invoke('save'), promiseLabel).then(() => manyArray, null, 'DS: ManyArray#save return ManyArray');\n\n // TODO deprecate returning a promiseArray here\n return Private.PromiseArray.create({\n promise\n });\n },\n /**\n Create a child record within the owner\n @method createRecord\n @public\n @param {Object} hash\n @return {Model} record\n */\n createRecord(hash) {\n const {\n store,\n type\n } = this;\n let record = store.createRecord(type.modelName, hash);\n this.pushObject(record);\n return record;\n }\n });\n\n /**\n @module @ember-data/model\n */\n\n /**\n A PromiseBelongsTo is a PromiseObject that also proxies certain method calls\n to the underlying belongsTo model.\n Right now we proxy:\n\n * `reload()`\n\n @class PromiseBelongsTo\n @extends PromiseObject\n @private\n */\n const PromiseBelongsTo = Private.PromiseObject.extend({\n // we don't proxy meta because we would need to proxy it to the relationship state container\n // however, meta on relationships does not trigger change notifications.\n // if you need relationship meta, you should do `record.belongsTo(relationshipName).meta()`\n meta: EmberObject.computed(function () {\n (debug.assert('You attempted to access meta on the promise for the async belongsTo relationship ' + `${this.get('_belongsToState').modelName}:${this.get('_belongsToState').key}'.` + '\\nUse `record.belongsTo(relationshipName).meta()` instead.', false));\n }),\n reload(options) {\n (!(this.get('content') !== undefined) && debug.assert('You are trying to reload an async belongsTo before it has been created', this.get('content') !== undefined));\n let {\n key,\n store,\n originatingInternalModel\n } = this._belongsToState;\n return store.reloadBelongsTo(this, originatingInternalModel, key, options).then(() => this);\n }\n });\n\n var _class, _descriptor, _descriptor2, _descriptor3, _descriptor4, _descriptor5;\n function _initializerDefineProperty(e, i, r, l) { r && Object.defineProperty(e, i, { enumerable: r.enumerable, configurable: r.configurable, writable: r.writable, value: r.initializer ? r.initializer.call(l) : void 0 }); }\n function _applyDecoratedDescriptor(i, e, r, n, l) { var a = {}; return Object.keys(n).forEach(function (i) { a[i] = n[i]; }), a.enumerable = !!a.enumerable, a.configurable = !!a.configurable, (\"value\" in a || a.initializer) && (a.writable = !0), a = r.slice().reverse().reduce(function (r, n) { return n(i, e, r) || r; }, a), l && void 0 !== a.initializer && (a.value = a.initializer ? a.initializer.call(l) : void 0, a.initializer = void 0), void 0 === a.initializer ? (Object.defineProperty(i, e, a), null) : a; }\n\n /**\n @module @ember-data/model\n */\n /**\n This class is returned as the result of accessing an async hasMany relationship\n on an instance of a Model extending from `@ember-data/model`.\n\n A PromiseManyArray is an array-like proxy that also proxies certain method calls\n to the underlying ManyArray in addition to being \"promisified\".\n\n Right now we proxy:\n\n * `reload()`\n * `createRecord()`\n\n This promise-proxy behavior is primarily to ensure that async relationship interact\n nicely with templates. In your JS code you should resolve the promise first.\n\n ```js\n const comments = await post.comments;\n ```\n\n @class PromiseManyArray\n @public\n */\n let PromiseManyArray = (_class = class PromiseManyArray {\n constructor(promise, content) {\n //---- Methods/Properties on ArrayProxy that we will keep as our API\n _initializerDefineProperty(this, \"content\", _descriptor, this);\n //---- Properties/Methods from the PromiseProxyMixin that we will keep as our API\n /**\n * Whether the loading promise is still pending\n *\n * @property {boolean} isPending\n * @public\n */\n _initializerDefineProperty(this, \"isPending\", _descriptor2, this);\n /**\n * Whether the loading promise rejected\n *\n * @property {boolean} isRejected\n * @public\n */\n _initializerDefineProperty(this, \"isRejected\", _descriptor3, this);\n /**\n * Whether the loading promise succeeded\n *\n * @property {boolean} isFulfilled\n * @public\n */\n _initializerDefineProperty(this, \"isFulfilled\", _descriptor4, this);\n /**\n * Whether the loading promise completed (resolved or rejected)\n *\n * @property {boolean} isSettled\n * @public\n */\n _initializerDefineProperty(this, \"isSettled\", _descriptor5, this);\n this._update(promise, content);\n this.isDestroyed = false;\n this.isDestroying = false;\n const meta = Ember__default[\"default\"].meta(this);\n meta.hasMixin = mixin => {\n if (mixin === EmberArray__default[\"default\"]) {\n return true;\n }\n return false;\n };\n }\n /**\n * Retrieve the length of the content\n * @property length\n * @public\n */\n get length() {\n // shouldn't be needed, but ends up being needed\n // for computed chains even in 4.x\n this['[]'];\n return this.content ? this.content.length : 0;\n }\n\n // ember-source < 3.23 (e.g. 3.20 lts)\n // requires that the tag `'[]'` be notified\n // on the ArrayProxy in order for `{{#each}}`\n // to recompute. We entangle the '[]' tag from\n get '[]'() {\n return this.content ? this.content['[]'] : this.content;\n }\n\n /**\n * Iterate the proxied content. Called by the glimmer iterator in #each\n *\n * @method forEach\n * @param cb\n * @returns\n * @private\n */\n forEach(cb) {\n this['[]']; // needed for < 3.23 support e.g. 3.20 lts\n if (this.content && this.length) {\n this.content.forEach(cb);\n }\n }\n /**\n * chain this promise\n *\n * @method then\n * @public\n * @param success\n * @param fail\n * @returns Promise\n */\n then(s, f) {\n return this.promise.then(s, f);\n }\n\n /**\n * catch errors thrown by this promise\n * @method catch\n * @public\n * @param callback\n * @returns Promise\n */\n catch(cb) {\n return this.promise.catch(cb);\n }\n\n /**\n * run cleanup after this promise completes\n *\n * @method finally\n * @public\n * @param callback\n * @returns Promise\n */\n finally(cb) {\n return this.promise.finally(cb);\n }\n\n //---- Methods on EmberObject that we should keep\n\n destroy() {\n this.isDestroying = true;\n this.isDestroyed = true;\n this.content = null;\n this.promise = null;\n }\n\n //---- Methods/Properties on ManyArray that we own and proxy to\n\n /**\n * Retrieve the links for this relationship\n * @property links\n * @public\n */\n get links() {\n return this.content ? this.content.links : undefined;\n }\n\n /**\n * Retrieve the meta for this relationship\n * @property meta\n * @public\n */\n get meta() {\n return this.content ? this.content.meta : undefined;\n }\n\n /**\n * Reload the relationship\n * @method reload\n * @public\n * @param options\n * @returns\n */\n reload(options) {\n (!(this.content) && debug.assert('You are trying to reload an async manyArray before it has been created', this.content));\n this.content.reload(options);\n return this;\n }\n\n //---- Our own stuff\n\n _update(promise, content) {\n if (content !== undefined) {\n this.content = content;\n }\n this.promise = tapPromise(this, promise);\n }\n static create({\n promise,\n content\n }) {\n return new this(promise, content);\n }\n\n // Methods on ManyArray which people should resolve the relationship first before calling\n createRecord(...args) {\n (!(this.content) && debug.assert('You are trying to createRecord on an async manyArray before it has been created', this.content));\n return this.content.createRecord(...args);\n }\n\n // Properties/Methods on ArrayProxy we should deprecate\n\n get firstObject() {\n return this.content ? this.content.firstObject : undefined;\n }\n get lastObject() {\n return this.content ? this.content.lastObject : undefined;\n }\n }, _descriptor = _applyDecoratedDescriptor(_class.prototype, \"content\", [tracking.tracked], {\n configurable: true,\n enumerable: true,\n writable: true,\n initializer: function () {\n return null;\n }\n }), _applyDecoratedDescriptor(_class.prototype, \"length\", [compat.dependentKeyCompat], Object.getOwnPropertyDescriptor(_class.prototype, \"length\"), _class.prototype), _applyDecoratedDescriptor(_class.prototype, '[]', [compat.dependentKeyCompat], Object.getOwnPropertyDescriptor(_class.prototype, '[]'), _class.prototype), _descriptor2 = _applyDecoratedDescriptor(_class.prototype, \"isPending\", [tracking.tracked], {\n configurable: true,\n enumerable: true,\n writable: true,\n initializer: function () {\n return false;\n }\n }), _descriptor3 = _applyDecoratedDescriptor(_class.prototype, \"isRejected\", [tracking.tracked], {\n configurable: true,\n enumerable: true,\n writable: true,\n initializer: function () {\n return false;\n }\n }), _descriptor4 = _applyDecoratedDescriptor(_class.prototype, \"isFulfilled\", [tracking.tracked], {\n configurable: true,\n enumerable: true,\n writable: true,\n initializer: function () {\n return false;\n }\n }), _descriptor5 = _applyDecoratedDescriptor(_class.prototype, \"isSettled\", [tracking.tracked], {\n configurable: true,\n enumerable: true,\n writable: true,\n initializer: function () {\n return false;\n }\n }), _applyDecoratedDescriptor(_class.prototype, \"links\", [compat.dependentKeyCompat], Object.getOwnPropertyDescriptor(_class.prototype, \"links\"), _class.prototype), _applyDecoratedDescriptor(_class.prototype, \"meta\", [compat.dependentKeyCompat], Object.getOwnPropertyDescriptor(_class.prototype, \"meta\"), _class.prototype), _class);\n function tapPromise(proxy, promise) {\n proxy.isPending = true;\n proxy.isSettled = false;\n proxy.isFulfilled = false;\n proxy.isRejected = false;\n return rsvp.resolve(promise).then(content => {\n proxy.isPending = false;\n proxy.isFulfilled = true;\n proxy.isSettled = true;\n proxy.content = content;\n return content;\n }, error => {\n proxy.isPending = false;\n proxy.isFulfilled = false;\n proxy.isRejected = true;\n proxy.isSettled = true;\n throw error;\n });\n }\n const EmberObjectMethods = ['addObserver', 'cacheFor', 'decrementProperty', 'get', 'getProperties', 'incrementProperty', 'notifyPropertyChange', 'removeObserver', 'set', 'setProperties', 'toggleProperty'];\n EmberObjectMethods.forEach(method => {\n PromiseManyArray.prototype[method] = function delegatedMethod(...args) {\n return Ember__default[\"default\"][method](this, ...args);\n };\n });\n const InheritedProxyMethods = ['addArrayObserver', 'addObject', 'addObjects', 'any', 'arrayContentDidChange', 'arrayContentWillChange', 'clear', 'compact', 'every', 'filter', 'filterBy', 'find', 'findBy', 'getEach', 'includes', 'indexOf', 'insertAt', 'invoke', 'isAny', 'isEvery', 'lastIndexOf', 'map', 'mapBy', 'objectAt', 'objectsAt', 'popObject', 'pushObject', 'pushObjects', 'reduce', 'reject', 'rejectBy', 'removeArrayObserver', 'removeAt', 'removeObject', 'removeObjects', 'replace', 'reverseObjects', 'setEach', 'setObjects', 'shiftObject', 'slice', 'sortBy', 'toArray', 'uniq', 'uniqBy', 'unshiftObject', 'unshiftObjects', 'without'];\n InheritedProxyMethods.forEach(method => {\n PromiseManyArray.prototype[method] = function proxiedMethod(...args) {\n (!(this.content) && debug.assert(`Cannot call ${method} before content is assigned.`, this.content));\n return this.content[method](...args);\n };\n });\n\n /* \n In case someone defined a relationship to a mixin, for example:\n ```\n import Model, { belongsTo, hasMany } from '@ember-data/model';\n import Mixin from '@ember/object/mixin';\n\n class CommentModel extends Model {\n @belongsTo('commentable', { polymorphic: true }) owner;\n }\n\n let Commentable = Mixin.create({\n @hasMany('comment') comments;\n });\n ```\n we want to look up a Commentable class which has all the necessary\n relationship meta data. Thus, we look up the mixin and create a mock\n Model, so we can access the relationship CPs of the mixin (`comments`)\n in this case\n */\n function modelForMixin(store, normalizedModelName) {\n let owner = application.getOwner(store);\n let MaybeMixin = owner.factoryFor(`mixin:${normalizedModelName}`);\n let mixin = MaybeMixin && MaybeMixin.class;\n if (mixin) {\n let ModelForMixin = Model.extend(mixin);\n ModelForMixin.reopenClass({\n __isMixin: true,\n __mixin: mixin\n });\n //Cache the class as a model\n owner.register('model:' + normalizedModelName, ModelForMixin);\n }\n return owner.factoryFor(`model:${normalizedModelName}`);\n }\n\n exports.Errors = Errors;\n exports.ManyArray = manyArray;\n exports.Model = Model;\n exports.PromiseBelongsTo = PromiseBelongsTo;\n exports.PromiseManyArray = PromiseManyArray;\n exports._modelForMixin = modelForMixin;\n exports.attr = attr$1;\n exports.belongsTo = belongsTo$1;\n exports.diffArray = diffArray;\n exports.hasMany = hasMany$1;\n\n Object.defineProperty(exports, '__esModule', { value: true });\n\n}));\n","define(\"@ember-data/model/index\", [\"exports\", \"@ember-data/model/-private\"], function (_exports, _private) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n Object.defineProperty(_exports, \"attr\", {\n enumerable: true,\n get: function () {\n return _private.attr;\n }\n });\n Object.defineProperty(_exports, \"belongsTo\", {\n enumerable: true,\n get: function () {\n return _private.belongsTo;\n }\n });\n Object.defineProperty(_exports, \"default\", {\n enumerable: true,\n get: function () {\n return _private.Model;\n }\n });\n Object.defineProperty(_exports, \"hasMany\", {\n enumerable: true,\n get: function () {\n return _private.hasMany;\n }\n });\n 0; //eaimeta@70e063a35619d71f0,\"@ember-data/model/-private\"eaimeta@70e063a35619d71f\n /**\n In EmberData a `Model` is a class defining the attributes and relationships\n of a specific resource `type` (model name). In this sense it represents a static \"schema\".\n \n Data for individual resources fetched from your API is presented\n to the UI via instances of the `Model`s you define.\n \n An instantiated `Model` is referred to as a `record`.\n \n When we refer to the `ModelClass` we are referring to the class definition\n and the static schema methods present on it.\n \n When we refer to a `record` we refer to a specific class instance presenting\n the resource data for a given `type` and `id`.\n \n ### Defining a Model\n \n ```app/models/person.js\n import Model, { attr, belongsTo, hasMany } from '@ember-data/model';\n \n export default class PersonModel extends Model {\n @attr name;\n \n @belongsTo('pet', { inverse: 'owners', async: false }) dog;\n \n @hasMany('person', { inverse: 'friends', async: true }) friends;\n }\n ```\n \n ### modelName convention\n \n By convention, the name of a given model (its `type`) matches the name\n of the file in the `app/models` folder and should be lowercase, singular\n and dasherized.\n \n @module @ember-data/model\n @main @ember-data/model\n */\n});","define(\"@ember-data/private-build-infra/available-packages\", [\"exports\"], function (_exports) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.default = void 0;\n var _default = _exports.default = {\n HAS_EMBER_DATA_PACKAGE: 'ember-data',\n HAS_STORE_PACKAGE: '@ember-data/store',\n HAS_MODEL_PACKAGE: '@ember-data/model',\n HAS_RECORD_DATA_PACKAGE: '@ember-data/record-data',\n HAS_ADAPTER_PACKAGE: '@ember-data/adapter',\n HAS_SERIALIZER_PACKAGE: '@ember-data/serializer',\n HAS_DEBUG_PACKAGE: '@ember-data/debug'\n };\n});","define(\"@ember-data/private-build-infra/current-deprecations\", [\"exports\"], function (_exports) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.default = void 0;\n /**\n * ## Deprecations\n *\n * EmberData allows users to opt-in and remove code that exists to support deprecated\n * behaviors.\n *\n * If your app has resolved all deprecations present in a given version,\n * you may specify that version as your \"compatibility\" version to remove\n * the code that supported the deprecated behavior from your app.\n *\n * For instance, if a deprecation was introduced in 3.13, and the app specifies\n * 3.13 as its minimum version compatibility, any deprecations introduced before\n * or during 3.13 would be stripped away.\n *\n * An app can use a different version than what it specifies as it's compatibility\n * version. For instance, an App could be using `3.16` while specifying compatibility\n * with `3.12`. This would remove any deprecations that were present in or before `3.12`\n * but keep support for anything deprecated in or above `3.13`.\n *\n * ### Configuring Compatibility\n *\n * To configure your compatibility version, set the `compatWith` to the version you\n * are compatible with on the `emberData` config in your `ember-cli-build.js` file.\n *\n * ```js\n * let app = new EmberApp(defaults, {\n * emberData: {\n * compatWith: '3.12',\n * },\n * });\n * ```\n *\n * The complete list of which versions specific deprecations will be removed in\n * can be found [here](https://github.com/emberjs/data/tree/master/packages/private-build-infra/addon/current-deprecations.ts \"List of EmberData Deprecations\")\n *\n * @module @ember-data/deprecations\n * @main @ember-data/deprecations\n */\n var _default = _exports.default = {\n DEPRECATE_CATCH_ALL: '99.0',\n DEPRECATE_3_12: '3.12',\n DEPRECATE_SAVE_PROMISE_ACCESS: '4.4'\n };\n});","define(\"@ember-data/private-build-infra/deprecations\", [\"exports\", \"@ember-data/private-build-infra/current-deprecations\"], function (_exports, _currentDeprecations) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.DEPRECATE_SAVE_PROMISE_ACCESS = _exports.DEPRECATE_CATCH_ALL = _exports.DEPRECATE_3_12 = void 0;\n function deprecationState(deprecationName) {\n // if we hit this at runtime and the deprecation exists it is always activated\n return deprecationName in _currentDeprecations.default;\n }\n\n // deprecations\n const DEPRECATE_CATCH_ALL = _exports.DEPRECATE_CATCH_ALL = deprecationState('DEPRECATE_CATCH_ALL');\n const DEPRECATE_3_12 = _exports.DEPRECATE_3_12 = deprecationState('DEPRECATE_3_12');\n const DEPRECATE_SAVE_PROMISE_ACCESS = _exports.DEPRECATE_SAVE_PROMISE_ACCESS = deprecationState('DEPRECATE_SAVE_PROMISE_ACCESS');\n});","define(\"@ember-data/private-build-infra/index\", [\"exports\", \"require\", \"@ember-data/private-build-infra/available-packages\"], function (_exports, _require, _availablePackages) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.HAS_STORE_PACKAGE = _exports.HAS_SERIALIZER_PACKAGE = _exports.HAS_RECORD_DATA_PACKAGE = _exports.HAS_MODEL_PACKAGE = _exports.HAS_EMBER_DATA_PACKAGE = _exports.HAS_DEBUG_PACKAGE = _exports.HAS_ADAPTER_PACKAGE = void 0;\n function flagState(flag) {\n const packageName = _availablePackages.default[flag];\n return (0, _require.has)(packageName) || false;\n }\n const HAS_EMBER_DATA_PACKAGE = _exports.HAS_EMBER_DATA_PACKAGE = flagState('HAS_EMBER_DATA_PACKAGE');\n const HAS_STORE_PACKAGE = _exports.HAS_STORE_PACKAGE = flagState('HAS_STORE_PACKAGE');\n const HAS_MODEL_PACKAGE = _exports.HAS_MODEL_PACKAGE = flagState('HAS_MODEL_PACKAGE');\n const HAS_ADAPTER_PACKAGE = _exports.HAS_ADAPTER_PACKAGE = flagState('HAS_ADAPTER_PACKAGE');\n const HAS_SERIALIZER_PACKAGE = _exports.HAS_SERIALIZER_PACKAGE = flagState('HAS_SERIALIZER_PACKAGE');\n const HAS_DEBUG_PACKAGE = _exports.HAS_DEBUG_PACKAGE = flagState('HAS_DEBUG_PACKAGE');\n const HAS_RECORD_DATA_PACKAGE = _exports.HAS_RECORD_DATA_PACKAGE = flagState('HAS_RECORD_DATA_PACKAGE');\n});","define('@ember-data/record-data/-private', ['exports', '@ember/debug', '@ember/runloop', '@ember/utils', '@ember-data/store/-private', '@ember-data/store/-debug'], (function (exports, debug, runloop, utils, Private, Debug) { 'use strict';\n\n // Used by the store to normalize IDs entering the store. Despite the fact\n // that developers may provide IDs as numbers (e.g., `store.findRecord('person', 1)`),\n // it is important that internally we use strings, since IDs may be serialized\n // and lose type information. For example, Ember's router may put a record's\n // ID into the URL, and if we later try to deserialize that URL and find the\n // corresponding record, we will not know if it is a string or a number.\n\n function coerceId(id) {\n if (id === null || id === undefined || id === '') {\n return null;\n }\n if (typeof id === 'string') {\n return id;\n }\n if (typeof id === 'symbol') {\n return id.toString();\n }\n return '' + id;\n }\n\n function expandingGet(cache, key1, key2) {\n let mainCache = cache[key1] = cache[key1] || Object.create(null);\n return mainCache[key2];\n }\n function expandingSet(cache, key1, key2, value) {\n let mainCache = cache[key1] = cache[key1] || Object.create(null);\n mainCache[key2] = value;\n }\n function assertValidRelationshipPayload(graph, op) {\n const relationship = graph.get(op.record, op.field);\n (!(isHasMany(relationship) || isBelongsTo(relationship)) && debug.assert(`Cannot update an implicit relationship`, isHasMany(relationship) || isBelongsTo(relationship)));\n const payload = op.value;\n const {\n definition,\n identifier,\n state\n } = relationship;\n const {\n type\n } = identifier;\n const {\n field\n } = op;\n const {\n isAsync,\n kind\n } = definition;\n if (payload.links) {\n (debug.warn(`You pushed a record of type '${type}' with a relationship '${field}' configured as 'async: false'. You've included a link but no primary data, this may be an error in your payload. EmberData will treat this relationship as known-to-be-empty.`, isAsync || !!payload.data || state.hasReceivedData, {\n id: 'ds.store.push-link-for-sync-relationship'\n }));\n } else if (payload.data) {\n if (kind === 'belongsTo') {\n (!(!Array.isArray(payload.data)) && debug.assert(`A ${type} record was pushed into the store with the value of ${field} being ${debug.inspect(payload.data)}, but ${field} is a belongsTo relationship so the value must not be an array. You should probably check your data payload or serializer.`, !Array.isArray(payload.data)));\n assertRelationshipData(graph.store._store, identifier, payload.data, definition);\n } else if (kind === 'hasMany') {\n (!(Array.isArray(payload.data)) && debug.assert(`A ${type} record was pushed into the store with the value of ${field} being '${debug.inspect(payload.data)}', but ${field} is a hasMany relationship so the value must be an array. You should probably check your data payload or serializer.`, Array.isArray(payload.data)));\n if (Array.isArray(payload.data)) {\n for (let i = 0; i < payload.data.length; i++) {\n assertRelationshipData(graph.store._store, identifier, payload.data[i], definition);\n }\n }\n }\n }\n }\n function isNew(identifier) {\n if (!identifier.id) {\n return true;\n }\n const recordData = Private.recordDataFor(identifier);\n return recordData ? isRelationshipRecordData(recordData) && recordData.isNew() : false;\n }\n function isRelationshipRecordData(recordData) {\n return typeof recordData.isNew === 'function';\n }\n function isBelongsTo(relationship) {\n return relationship.definition.kind === 'belongsTo';\n }\n function isImplicit(relationship) {\n return relationship.definition.isImplicit;\n }\n function isHasMany(relationship) {\n return relationship.definition.kind === 'hasMany';\n }\n function assertRelationshipData(store, identifier, data, meta) {\n (!(!Array.isArray(data)) && debug.assert(`A ${identifier.type} record was pushed into the store with the value of ${meta.key} being '${JSON.stringify(data)}', but ${meta.key} is a belongsTo relationship so the value must not be an array. You should probably check your data payload or serializer.`, !Array.isArray(data)));\n (!(data === null || typeof data.type === 'string' && data.type.length) && debug.assert(`Encountered a relationship identifier without a type for the ${meta.kind} relationship '${meta.key}' on <${identifier.type}:${identifier.id}>, expected a json-api identifier with type '${meta.type}' but found '${JSON.stringify(data)}'. Please check your serializer and make sure it is serializing the relationship payload into a JSON API format.`, data === null || typeof data.type === 'string' && data.type.length));\n (!(data === null || !!Private.coerceId(data.id)) && debug.assert(`Encountered a relationship identifier without an id for the ${meta.kind} relationship '${meta.key}' on <${identifier.type}:${identifier.id}>, expected a json-api identifier but found '${JSON.stringify(data)}'. Please check your serializer and make sure it is serializing the relationship payload into a JSON API format.`, data === null || !!Private.coerceId(data.id)));\n (!(data === null || !data.type || store._hasModelFor(data.type)) && debug.assert(`Encountered a relationship identifier with type '${data.type}' for the ${meta.kind} relationship '${meta.key}' on <${identifier.type}:${identifier.id}>, Expected a json-api identifier with type '${meta.type}'. No model was found for '${data.type}'.`, data === null || !data.type || store._hasModelFor(data.type)));\n }\n\n function createState() {\n return {\n hasReceivedData: false,\n isEmpty: true,\n isStale: false,\n hasFailedLoadAttempt: false,\n shouldForceReload: false,\n hasDematerializedInverse: false\n };\n }\n\n class BelongsToRelationship {\n constructor(graph, definition, identifier) {\n this.graph = graph;\n this.store = graph.store;\n this.definition = definition;\n this.identifier = identifier;\n this._state = null;\n this.transactionRef = 0;\n this.meta = null;\n this.links = null;\n this.localState = null;\n this.remoteState = null;\n }\n get state() {\n let {\n _state\n } = this;\n if (!_state) {\n _state = this._state = createState();\n }\n return _state;\n }\n recordDataDidDematerialize() {\n if (this.definition.inverseIsImplicit) {\n return;\n }\n const inverseKey = this.definition.inverseKey;\n const callback = inverseIdentifier => {\n if (!inverseIdentifier || !this.graph.has(inverseIdentifier, inverseKey)) {\n return;\n }\n let relationship = this.graph.get(inverseIdentifier, inverseKey);\n\n // For canonical members, it is possible that inverseRecordData has already been associated to\n // to another record. For such cases, do not dematerialize the inverseRecordData\n if (relationship.definition.kind !== 'belongsTo' || !relationship.localState || this.identifier === relationship.localState) {\n relationship.inverseDidDematerialize(this.identifier);\n }\n };\n if (this.remoteState) {\n callback(this.remoteState);\n }\n if (this.localState && this.localState !== this.remoteState) {\n callback(this.localState);\n }\n }\n inverseDidDematerialize() {\n const inverseRecordData = this.localState;\n if (!this.definition.isAsync || inverseRecordData && isNew(inverseRecordData)) {\n // unloading inverse of a sync relationship is treated as a client-side\n // delete, so actually remove the models don't merely invalidate the cp\n // cache.\n // if the record being unloaded only exists on the client, we similarly\n // treat it as a client side delete\n if (this.localState === inverseRecordData && inverseRecordData !== null) {\n this.localState = null;\n }\n if (this.remoteState === inverseRecordData && inverseRecordData !== null) {\n this.remoteState = null;\n this.state.hasReceivedData = true;\n this.state.isEmpty = true;\n if (this.localState && !isNew(this.localState)) {\n this.localState = null;\n }\n }\n } else {\n this.state.hasDematerializedInverse = true;\n }\n this.notifyBelongsToChange();\n }\n getData() {\n let data;\n let payload = {};\n if (this.localState) {\n data = this.localState;\n }\n if (this.localState === null && this.state.hasReceivedData) {\n data = null;\n }\n if (this.links) {\n payload.links = this.links;\n }\n if (data !== undefined) {\n payload.data = data;\n }\n if (this.meta) {\n payload.meta = this.meta;\n }\n payload._relationship = this;\n return payload;\n }\n\n /*\n Removes the given RecordData from BOTH canonical AND current state.\n \n This method is useful when either a deletion or a rollback on a new record\n needs to entirely purge itself from an inverse relationship.\n */\n removeCompletelyFromOwn(recordData) {\n if (this.remoteState === recordData) {\n this.remoteState = null;\n }\n if (this.localState === recordData) {\n this.localState = null;\n // This allows dematerialized inverses to be rematerialized\n // we shouldn't be notifying here though, figure out where\n // a notification was missed elsewhere.\n this.notifyBelongsToChange();\n }\n }\n notifyBelongsToChange() {\n let recordData = this.identifier;\n this.store.notifyBelongsToChange(recordData.type, recordData.id, recordData.lid, this.definition.key);\n }\n clear() {\n this.localState = null;\n this.remoteState = null;\n this.state.hasReceivedData = false;\n this.state.isEmpty = true;\n }\n }\n\n class ManyRelationship {\n constructor(graph, definition, identifier) {\n this.graph = graph;\n this.store = graph.store;\n this.definition = definition;\n this.identifier = identifier;\n this._state = null;\n this.transactionRef = 0;\n this.members = new Set();\n this.canonicalMembers = new Set();\n this.meta = null;\n this.links = null;\n\n // persisted state\n this.canonicalState = [];\n // local client state\n this.currentState = [];\n this._willUpdateManyArray = false;\n this._pendingManyArrayUpdates = null;\n }\n get state() {\n let {\n _state\n } = this;\n if (!_state) {\n _state = this._state = createState();\n }\n return _state;\n }\n recordDataDidDematerialize() {\n if (this.definition.inverseIsImplicit) {\n return;\n }\n const inverseKey = this.definition.inverseKey;\n this.forAllMembers(inverseIdentifier => {\n if (!inverseIdentifier || !this.graph.has(inverseIdentifier, inverseKey)) {\n return;\n }\n let relationship = this.graph.get(inverseIdentifier, inverseKey);\n (!(!isImplicit(relationship)) && debug.assert(`expected no implicit`, !isImplicit(relationship))); // For canonical members, it is possible that inverseRecordData has already been associated to\n // to another record. For such cases, do not dematerialize the inverseRecordData\n if (relationship.definition.kind !== 'belongsTo' || !relationship.localState || this.identifier === relationship.localState) {\n relationship.inverseDidDematerialize(this.identifier);\n }\n });\n }\n forAllMembers(callback) {\n // ensure we don't walk anything twice if an entry is\n // in both members and canonicalMembers\n let seen = Object.create(null);\n for (let i = 0; i < this.currentState.length; i++) {\n const inverseInternalModel = this.currentState[i];\n const id = inverseInternalModel.lid;\n if (!seen[id]) {\n seen[id] = true;\n callback(inverseInternalModel);\n }\n }\n for (let i = 0; i < this.canonicalState.length; i++) {\n const inverseInternalModel = this.canonicalState[i];\n const id = inverseInternalModel.lid;\n if (!seen[id]) {\n seen[id] = true;\n callback(inverseInternalModel);\n }\n }\n }\n clear() {\n this.members.clear();\n this.canonicalMembers.clear();\n this.currentState = [];\n this.canonicalState = [];\n }\n inverseDidDematerialize(inverseRecordData) {\n if (!this.definition.isAsync || inverseRecordData && isNew(inverseRecordData)) {\n // unloading inverse of a sync relationship is treated as a client-side\n // delete, so actually remove the models don't merely invalidate the cp\n // cache.\n // if the record being unloaded only exists on the client, we similarly\n // treat it as a client side delete\n this.removeCompletelyFromOwn(inverseRecordData);\n } else {\n this.state.hasDematerializedInverse = true;\n }\n this.notifyHasManyChange();\n }\n\n /*\n Removes the given RecordData from BOTH canonical AND current state.\n This method is useful when either a deletion or a rollback on a new record\n needs to entirely purge itself from an inverse relationship.\n */\n removeCompletelyFromOwn(recordData) {\n this.canonicalMembers.delete(recordData);\n this.members.delete(recordData);\n const canonicalIndex = this.canonicalState.indexOf(recordData);\n if (canonicalIndex !== -1) {\n this.canonicalState.splice(canonicalIndex, 1);\n }\n const currentIndex = this.currentState.indexOf(recordData);\n if (currentIndex !== -1) {\n this.currentState.splice(currentIndex, 1);\n // This allows dematerialized inverses to be rematerialized\n // we shouldn't be notifying here though, figure out where\n // a notification was missed elsewhere.\n this.notifyHasManyChange();\n }\n }\n notifyHasManyChange() {\n const {\n store,\n identifier: recordData\n } = this;\n store.notifyHasManyChange(recordData.type, recordData.id, recordData.lid, this.definition.key);\n }\n getData() {\n let payload = {};\n if (this.state.hasReceivedData) {\n payload.data = this.currentState.slice();\n }\n if (this.links) {\n payload.links = this.links;\n }\n if (this.meta) {\n payload.meta = this.meta;\n }\n return payload;\n }\n }\n\n /**\n @module @ember-data/store\n */\n class ImplicitRelationship {\n constructor(graph, definition, identifier) {\n this.graph = graph;\n this.definition = definition;\n this.identifier = identifier;\n this.members = new Set();\n this.canonicalMembers = new Set();\n }\n addCanonicalRecordData(recordData, idx) {\n if (!this.canonicalMembers.has(recordData)) {\n this.canonicalMembers.add(recordData);\n this.members.add(recordData);\n }\n }\n addRecordData(recordData, idx) {\n if (!this.members.has(recordData)) {\n this.members.add(recordData);\n }\n }\n removeRecordData(recordData) {\n if (recordData && this.members.has(recordData)) {\n this.members.delete(recordData);\n }\n }\n removeCompletelyFromOwn(recordData) {\n this.canonicalMembers.delete(recordData);\n this.members.delete(recordData);\n }\n clear() {\n this.canonicalMembers.clear();\n this.members.clear();\n }\n }\n\n const BOOL_LATER = null;\n const STR_LATER = '';\n const IMPLICIT_KEY_RAND = Date.now();\n function implicitKeyFor(type, key) {\n return `implicit-${type}:${key}${IMPLICIT_KEY_RAND}`;\n }\n function syncMeta(definition, inverseDefinition) {\n definition.inverseKind = inverseDefinition.kind;\n definition.inverseKey = inverseDefinition.key;\n definition.inverseType = inverseDefinition.type;\n definition.inverseIsAsync = inverseDefinition.isAsync;\n definition.inverseIsCollection = inverseDefinition.isCollection;\n definition.inverseIsPolymorphic = inverseDefinition.isPolymorphic;\n definition.inverseIsImplicit = inverseDefinition.isImplicit;\n }\n function upgradeMeta(meta) {\n let niceMeta = {};\n let options = meta.options;\n niceMeta.kind = meta.kind;\n niceMeta.key = meta.name;\n niceMeta.type = meta.type;\n niceMeta.isAsync = options && options.async !== undefined ? !!options.async : true;\n niceMeta.isImplicit = false;\n niceMeta.isCollection = meta.kind === 'hasMany';\n niceMeta.isPolymorphic = options && !!options.polymorphic;\n niceMeta.inverseKey = options && options.inverse || STR_LATER;\n niceMeta.inverseType = STR_LATER;\n niceMeta.inverseIsAsync = BOOL_LATER;\n niceMeta.inverseIsImplicit = options && options.inverse === null || BOOL_LATER;\n niceMeta.inverseIsCollection = BOOL_LATER;\n return niceMeta;\n }\n function isLHS(info, type, key) {\n let isSelfReferential = info.isSelfReferential;\n let isRelationship = key === info.lhs_relationshipName;\n if (isRelationship === true) {\n return isSelfReferential === true ||\n // itself\n type === info.lhs_baseModelName ||\n // base or non-polymorphic\n // if the other side is polymorphic then we need to scan our modelNames\n info.rhs_isPolymorphic && info.lhs_modelNames.indexOf(type) !== -1 // polymorphic\n ;\n }\n return false;\n }\n function upgradeDefinition(graph, identifier, propertyName, isImplicit = false) {\n const cache = graph._definitionCache;\n const storeWrapper = graph.store;\n const polymorphicLookup = graph._potentialPolymorphicTypes;\n const {\n type\n } = identifier;\n let cached = expandingGet(cache, type, propertyName);\n\n // CASE: We have a cached resolution (null if no relationship exists)\n if (cached !== undefined) {\n return cached;\n }\n (!(!isImplicit) && debug.assert(`Expected to find relationship definition in the cache for the implicit relationship ${propertyName}`, !isImplicit));\n let relationships = storeWrapper.relationshipsDefinitionFor(type);\n (!(relationships) && debug.assert(`Expected to have a relationship definition for ${type} but none was found.`, relationships));\n let meta = relationships[propertyName];\n if (!meta) {\n if (polymorphicLookup[type]) {\n const altTypes = Object.keys(polymorphicLookup[type]);\n for (let i = 0; i < altTypes.length; i++) {\n let cached = expandingGet(cache, altTypes[i], propertyName);\n if (cached) {\n expandingSet(cache, type, propertyName, cached);\n return cached;\n }\n }\n }\n\n // CASE: We don't have a relationship at all\n // we should only hit this in prod\n (!(meta) && debug.assert(`Expected to find a relationship definition for ${type}.${propertyName} but none was found.`, meta));\n cache[type][propertyName] = null;\n return null;\n }\n const definition = upgradeMeta(meta);\n let inverseDefinition;\n let inverseKey;\n const inverseType = definition.type;\n\n // CASE: Inverse is explicitly null\n if (definition.inverseKey === null) {\n (!(storeWrapper._store.modelFor(inverseType)) && debug.assert(`Expected the inverse model to exist`, storeWrapper._store.modelFor(inverseType)));\n inverseDefinition = null;\n } else {\n inverseKey = storeWrapper.inverseForRelationship(type, propertyName);\n\n // CASE: Inverse resolves to null\n if (!inverseKey) {\n inverseDefinition = null;\n } else {\n // CASE: We have an explicit inverse or were able to resolve one\n let inverseDefinitions = storeWrapper.relationshipsDefinitionFor(inverseType);\n (!(inverseDefinitions) && debug.assert(`Expected to have a relationship definition for ${inverseType} but none was found.`, inverseDefinitions));\n let meta = inverseDefinitions[inverseKey];\n (!(meta) && debug.assert(`Expected to find a relationship definition for ${inverseType}.${inverseKey} but none was found.`, meta));\n inverseDefinition = upgradeMeta(meta);\n }\n }\n\n // CASE: We have no inverse\n if (!inverseDefinition) {\n // polish off meta\n inverseKey = implicitKeyFor(type, propertyName);\n inverseDefinition = {\n kind: 'implicit',\n key: inverseKey,\n type: type,\n isAsync: false,\n isImplicit: true,\n isCollection: true,\n // with implicits any number of records could point at us\n isPolymorphic: false\n };\n syncMeta(definition, inverseDefinition);\n syncMeta(inverseDefinition, definition);\n const info = {\n lhs_key: `${type}:${propertyName}`,\n lhs_modelNames: [type],\n lhs_baseModelName: type,\n lhs_relationshipName: propertyName,\n lhs_definition: definition,\n lhs_isPolymorphic: definition.isPolymorphic,\n rhs_key: '',\n rhs_modelNames: [],\n rhs_baseModelName: inverseType,\n rhs_relationshipName: '',\n rhs_definition: inverseDefinition,\n rhs_isPolymorphic: false,\n hasInverse: false,\n isSelfReferential: type === inverseType,\n // this could be wrong if we are self-referential but also polymorphic\n isReflexive: false // we can't be reflexive if we don't define an inverse\n };\n expandingSet(cache, inverseType, inverseKey, info);\n expandingSet(cache, type, propertyName, info);\n return info;\n }\n\n // CASE: We do have an inverse\n const baseType = inverseDefinition.type;\n\n // TODO we want to assert this but this breaks all of our shoddily written tests\n /*\n if (DEBUG) {\n let inverseDoubleCheck = inverseMeta.type.inverseFor(inverseRelationshipName, store);\n assert(`The ${inverseBaseModelName}:${inverseRelationshipName} relationship declares 'inverse: null', but it was resolved as the inverse for ${baseModelName}:${relationshipName}.`, inverseDoubleCheck);\n }\n */\n // CASE: We may have already discovered the inverse for the baseModelName\n // CASE: We have already discovered the inverse\n cached = expandingGet(cache, baseType, propertyName) || expandingGet(cache, inverseType, inverseKey);\n if (cached) {\n // TODO this assert can be removed if the above assert is enabled\n (!(cached.hasInverse !== false) && debug.assert(`The ${inverseType}:${inverseKey} relationship declares 'inverse: null', but it was resolved as the inverse for ${type}:${propertyName}.`, cached.hasInverse !== false));\n let isLHS = cached.lhs_baseModelName === baseType;\n let modelNames = isLHS ? cached.lhs_modelNames : cached.rhs_modelNames;\n // make this lookup easier in the future by caching the key\n modelNames.push(type);\n expandingSet(cache, type, propertyName, cached);\n return cached;\n }\n\n // this is our first time so polish off the metas\n syncMeta(definition, inverseDefinition);\n syncMeta(inverseDefinition, definition);\n const lhs_modelNames = [type];\n if (type !== baseType) {\n lhs_modelNames.push(baseType);\n }\n const isSelfReferential = type === inverseType;\n const info = {\n lhs_key: `${baseType}:${propertyName}`,\n lhs_modelNames,\n lhs_baseModelName: baseType,\n lhs_relationshipName: propertyName,\n lhs_definition: definition,\n lhs_isPolymorphic: definition.isPolymorphic,\n rhs_key: `${inverseType}:${inverseKey}`,\n rhs_modelNames: [inverseType],\n rhs_baseModelName: inverseType,\n rhs_relationshipName: inverseKey,\n rhs_definition: inverseDefinition,\n rhs_isPolymorphic: inverseDefinition.isPolymorphic,\n hasInverse: true,\n isSelfReferential,\n isReflexive: isSelfReferential && propertyName === inverseKey\n };\n\n // Create entries for the baseModelName as well as modelName to speed up\n // inverse lookups\n expandingSet(cache, baseType, propertyName, info);\n expandingSet(cache, type, propertyName, info);\n\n // Greedily populate the inverse\n expandingSet(cache, inverseType, inverseKey, info);\n return info;\n }\n\n /*\n case many:1\n ========\n In a bi-directional graph with Many:1 edges, adding a value\n results in up-to 3 discrete value transitions, while removing\n a value is only 2 transitions.\n\n For adding C to A\n If: A <<-> B, C <->> D is the initial state,\n and: B <->> A <<-> C, D is the final state\n\n then we would undergo the following transitions.\n\n add C to A\n remove C from D\n add A to C\n\n For removing B from A\n If: A <<-> B, C <->> D is the initial state,\n and: A, B, C <->> D is the final state\n\n then we would undergo the following transitions.\n\n remove B from A\n remove A from B\n\n case many:many\n ===========\n In a bi-directional graph with Many:Many edges, adding or\n removing a value requires only 2 value transitions.\n\n For Adding\n If: A<<->>B, C<<->>D is the initial state (double arrows representing the many side)\n And: D<<->>C<<->>A<<->>B is the final state\n\n Then we would undergo two transitions.\n\n add C to A.\n add A to C\n\n For Removing\n If: A<<->>B, C<<->>D is the initial state (double arrows representing the many side)\n And: A, B, C<<->>D is the final state\n\n Then we would undergo two transitions.\n\n remove B from A\n remove A from B\n\n case many:?\n ========\n In a uni-directional graph with Many:? edges (modeled in EmberData with `inverse:null`) with\n artificial (implicit) inverses, replacing a value results in 2 discrete value transitions.\n This is because a Many:? relationship is effectively Many:Many.\n */\n function replaceRelatedRecords(graph, op, isRemote) {\n if (isRemote) {\n replaceRelatedRecordsRemote(graph, op, isRemote);\n } else {\n replaceRelatedRecordsLocal(graph, op, isRemote);\n }\n }\n function replaceRelatedRecordsLocal(graph, op, isRemote) {\n const identifiers = op.value;\n const relationship = graph.get(op.record, op.field);\n (!(isHasMany(relationship)) && debug.assert(`expected hasMany relationship`, isHasMany(relationship)));\n relationship.state.hasReceivedData = true;\n\n // cache existing state\n const {\n currentState,\n members,\n definition\n } = relationship;\n const newValues = new Set(identifiers);\n const identifiersLength = identifiers.length;\n const newState = new Array(newValues.size);\n const newMembership = new Set();\n\n // wipe existing state\n relationship.members = newMembership;\n relationship.currentState = newState;\n const {\n type\n } = relationship.definition;\n let changed = false;\n const currentLength = currentState.length;\n const iterationLength = currentLength > identifiersLength ? currentLength : identifiersLength;\n const equalLength = currentLength === identifiersLength;\n for (let i = 0, j = 0; i < iterationLength; i++) {\n let adv = false;\n if (i < identifiersLength) {\n const identifier = identifiers[i];\n // skip processing if we encounter a duplicate identifier in the array\n if (!newMembership.has(identifier)) {\n if (type !== identifier.type) {\n Debug.assertPolymorphicType(relationship.identifier, relationship.definition, identifier, graph.store);\n graph.registerPolymorphicType(type, identifier.type);\n }\n newState[j] = identifier;\n adv = true;\n newMembership.add(identifier);\n if (!members.has(identifier)) {\n changed = true;\n addToInverse(graph, identifier, definition.inverseKey, op.record, isRemote);\n }\n }\n }\n if (i < currentLength) {\n const identifier = currentState[i];\n\n // detect reordering\n if (!newMembership.has(identifier)) {\n if (equalLength && newState[i] !== identifier) {\n changed = true;\n }\n if (!newValues.has(identifier)) {\n changed = true;\n removeFromInverse(graph, identifier, definition.inverseKey, op.record, isRemote);\n }\n }\n }\n if (adv) {\n j++;\n }\n }\n if (changed) {\n relationship.notifyHasManyChange();\n }\n }\n function replaceRelatedRecordsRemote(graph, op, isRemote) {\n const identifiers = op.value;\n const relationship = graph.get(op.record, op.field);\n (!(isHasMany(relationship)) && debug.assert(`You can only '${op.op}' on a hasMany relationship. ${op.record.type}.${op.field} is a ${relationship.definition.kind}`, isHasMany(relationship)));\n if (isRemote) {\n graph._addToTransaction(relationship);\n }\n relationship.state.hasReceivedData = true;\n\n // cache existing state\n const {\n canonicalState,\n canonicalMembers,\n definition\n } = relationship;\n const newValues = new Set(identifiers);\n const identifiersLength = identifiers.length;\n const newState = new Array(newValues.size);\n const newMembership = new Set();\n\n // wipe existing state\n relationship.canonicalMembers = newMembership;\n relationship.canonicalState = newState;\n const {\n type\n } = relationship.definition;\n let changed = false;\n const canonicalLength = canonicalState.length;\n const iterationLength = canonicalLength > identifiersLength ? canonicalLength : identifiersLength;\n const equalLength = canonicalLength === identifiersLength;\n for (let i = 0, j = 0; i < iterationLength; i++) {\n let adv = false;\n if (i < identifiersLength) {\n const identifier = identifiers[i];\n if (!newMembership.has(identifier)) {\n if (type !== identifier.type) {\n Debug.assertPolymorphicType(relationship.identifier, relationship.definition, identifier, graph.store);\n graph.registerPolymorphicType(type, identifier.type);\n }\n newState[j] = identifier;\n newMembership.add(identifier);\n adv = true;\n if (!canonicalMembers.has(identifier)) {\n changed = true;\n addToInverse(graph, identifier, definition.inverseKey, op.record, isRemote);\n }\n }\n }\n if (i < canonicalLength) {\n const identifier = canonicalState[i];\n if (!newMembership.has(identifier)) {\n // detect reordering\n if (equalLength && newState[j] !== identifier) {\n changed = true;\n }\n if (!newValues.has(identifier)) {\n changed = true;\n removeFromInverse(graph, identifier, definition.inverseKey, op.record, isRemote);\n }\n }\n }\n if (adv) {\n j++;\n }\n }\n if (changed) {\n flushCanonical(graph, relationship);\n /*\n replaceRelatedRecordsLocal(\n graph,\n {\n op: op.op,\n record: op.record,\n field: op.field,\n value: canonicalState,\n },\n false\n );*/\n } else {\n // preserve legacy behavior we want to change but requires some sort\n // of deprecation.\n flushCanonical(graph, relationship);\n }\n }\n function addToInverse(graph, identifier, key, value, isRemote) {\n const relationship = graph.get(identifier, key);\n const {\n type\n } = relationship.definition;\n if (type !== value.type) {\n Debug.assertPolymorphicType(relationship.identifier, relationship.definition, value, graph.store);\n graph.registerPolymorphicType(type, value.type);\n }\n if (isBelongsTo(relationship)) {\n relationship.state.hasReceivedData = true;\n relationship.state.isEmpty = false;\n if (isRemote) {\n graph._addToTransaction(relationship);\n if (relationship.remoteState !== null) {\n removeFromInverse(graph, relationship.remoteState, relationship.definition.inverseKey, identifier, isRemote);\n }\n relationship.remoteState = value;\n }\n if (relationship.localState !== value) {\n if (!isRemote && relationship.localState) {\n removeFromInverse(graph, relationship.localState, relationship.definition.inverseKey, identifier, isRemote);\n }\n relationship.localState = value;\n relationship.notifyBelongsToChange();\n }\n } else if (isHasMany(relationship)) {\n if (isRemote) {\n if (!relationship.canonicalMembers.has(value)) {\n graph._addToTransaction(relationship);\n relationship.canonicalState.push(value);\n relationship.canonicalMembers.add(value);\n relationship.state.hasReceivedData = true;\n flushCanonical(graph, relationship);\n }\n } else {\n if (!relationship.members.has(value)) {\n relationship.currentState.push(value);\n relationship.members.add(value);\n relationship.state.hasReceivedData = true;\n relationship.notifyHasManyChange();\n }\n }\n } else {\n if (isRemote) {\n relationship.addCanonicalRecordData(value);\n } else {\n relationship.addRecordData(value);\n }\n }\n }\n function removeFromInverse(graph, identifier, key, value, isRemote) {\n const relationship = graph.get(identifier, key);\n if (isBelongsTo(relationship)) {\n relationship.state.isEmpty = true;\n if (isRemote) {\n graph._addToTransaction(relationship);\n relationship.remoteState = null;\n }\n if (relationship.localState === value) {\n relationship.localState = null;\n relationship.notifyBelongsToChange();\n }\n } else if (isHasMany(relationship)) {\n if (isRemote) {\n graph._addToTransaction(relationship);\n let index = relationship.canonicalState.indexOf(value);\n if (index !== -1) {\n relationship.canonicalMembers.delete(value);\n relationship.canonicalState.splice(index, 1);\n }\n }\n let index = relationship.currentState.indexOf(value);\n if (index !== -1) {\n relationship.members.delete(value);\n relationship.currentState.splice(index, 1);\n }\n relationship.notifyHasManyChange();\n } else {\n if (isRemote) {\n relationship.removeCompletelyFromOwn(value);\n } else {\n relationship.removeRecordData(value);\n }\n }\n }\n function syncRemoteToLocal(rel) {\n let toSet = rel.canonicalState;\n let newRecordDatas = rel.currentState.filter(recordData => isNew(recordData) && toSet.indexOf(recordData) === -1);\n let existingState = rel.currentState;\n rel.currentState = toSet.concat(newRecordDatas);\n let members = rel.members = new Set();\n rel.canonicalMembers.forEach(v => members.add(v));\n for (let i = 0; i < newRecordDatas.length; i++) {\n members.add(newRecordDatas[i]);\n }\n\n // TODO always notifying fails only one test and we should probably do away with it\n if (existingState.length !== rel.currentState.length) {\n rel.notifyHasManyChange();\n } else {\n for (let i = 0; i < existingState.length; i++) {\n if (existingState[i] !== rel.currentState[i]) {\n rel.notifyHasManyChange();\n break;\n }\n }\n }\n }\n function flushCanonical(graph, rel) {\n graph._scheduleLocalSync(rel);\n }\n\n function addToRelatedRecords(graph, op, isRemote) {\n const {\n record,\n value,\n index\n } = op;\n const relationship = graph.get(record, op.field);\n (!(isHasMany(relationship)) && debug.assert(`You can only '${op.op}' on a hasMany relationship. ${record.type}.${op.field} is a ${relationship.definition.kind}`, isHasMany(relationship)));\n if (Array.isArray(value)) {\n for (let i = 0; i < value.length; i++) {\n addRelatedRecord(graph, relationship, record, value[i], index !== undefined ? index + i : index, isRemote);\n }\n } else {\n addRelatedRecord(graph, relationship, record, value, index, isRemote);\n }\n relationship.notifyHasManyChange();\n }\n function addRelatedRecord(graph, relationship, record, value, index, isRemote) {\n (!(value) && debug.assert(`expected an identifier to add to the relationship`, value));\n const {\n members,\n currentState\n } = relationship;\n if (members.has(value)) {\n return;\n }\n const {\n type\n } = relationship.definition;\n if (type !== value.type) {\n Debug.assertPolymorphicType(record, relationship.definition, value, graph.store);\n graph.registerPolymorphicType(value.type, type);\n }\n relationship.state.hasReceivedData = true;\n members.add(value);\n if (index === undefined) {\n currentState.push(value);\n } else {\n currentState.splice(index, 0, value);\n }\n addToInverse(graph, value, relationship.definition.inverseKey, record, isRemote);\n }\n\n function removeFromRelatedRecords(graph, op, isRemote) {\n const {\n record,\n value\n } = op;\n const relationship = graph.get(record, op.field);\n (!(isHasMany(relationship)) && debug.assert(`You can only '${op.op}' on a hasMany relationship. ${record.type}.${op.field} is a ${relationship.definition.kind}`, isHasMany(relationship)));\n if (Array.isArray(value)) {\n for (let i = 0; i < value.length; i++) {\n removeRelatedRecord(graph, relationship, record, value[i], isRemote);\n }\n } else {\n removeRelatedRecord(graph, relationship, record, value, isRemote);\n }\n relationship.notifyHasManyChange();\n }\n function removeRelatedRecord(graph, relationship, record, value, isRemote) {\n (!(value) && debug.assert(`expected an identifier to add to the relationship`, value));\n const {\n members,\n currentState\n } = relationship;\n if (!members.has(value)) {\n return;\n }\n members.delete(value);\n let index = currentState.indexOf(value);\n (!(index !== -1) && debug.assert(`expected members and currentState to be in sync`, index !== -1));\n currentState.splice(index, 1);\n removeFromInverse(graph, value, relationship.definition.inverseKey, record, isRemote);\n }\n\n function replaceRelatedRecord(graph, op, isRemote = false) {\n const relationship = graph.get(op.record, op.field);\n (!(isBelongsTo(relationship)) && debug.assert(`You can only '${op.op}' on a belongsTo relationship. ${op.record.type}.${op.field} is a ${relationship.definition.kind}`, isBelongsTo(relationship)));\n if (isRemote) {\n graph._addToTransaction(relationship);\n }\n const {\n definition,\n state\n } = relationship;\n const prop = isRemote ? 'remoteState' : 'localState';\n const existingState = relationship[prop];\n\n /*\n case 1:1\n ========\n In a bi-directional graph with 1:1 edges, replacing a value\n results in up-to 4 discrete value transitions.\n If: A <-> B, C <-> D is the initial state,\n and: A <-> C, B, D is the final state\n then we would undergo the following 4 transitions.\n remove A from B\n add C to A\n remove C from D\n add A to C\n case 1:many\n ===========\n In a bi-directional graph with 1:Many edges, replacing a value\n results in up-to 3 discrete value transitions.\n If: A<->>B<<->D, C<<->D is the initial state (double arrows representing the many side)\n And: A<->>C<<->D, B<<->D is the final state\n Then we would undergo three transitions.\n remove A from B\n add C to A.\n add A to C\n case 1:?\n ========\n In a uni-directional graph with 1:? edges (modeled in EmberData with `inverse:null`) with\n artificial (implicit) inverses, replacing a value results in up-to 3 discrete value transitions.\n This is because a 1:? relationship is effectively 1:many.\n If: A->B, C->B is the initial state\n And: A->C, C->B is the final state\n Then we would undergo three transitions.\n Remove A from B\n Add C to A\n Add A to C\n */\n\n // nothing for us to do\n if (op.value === existingState) {\n // if we were empty before but now know we are empty this needs to be true\n state.hasReceivedData = true;\n // if this is a remote update we still sync\n if (isRemote) {\n const {\n localState\n } = relationship;\n // don't sync if localState is a new record and our canonicalState is null\n if (localState && isNew(localState) && !existingState || localState === existingState) {\n return;\n }\n relationship.localState = existingState;\n relationship.notifyBelongsToChange();\n }\n return;\n }\n\n // remove this value from the inverse if required\n if (existingState) {\n removeFromInverse(graph, existingState, definition.inverseKey, op.record, isRemote);\n }\n\n // update value to the new value\n relationship[prop] = op.value;\n state.hasReceivedData = true;\n state.isEmpty = op.value === null;\n state.isStale = false;\n state.hasFailedLoadAttempt = false;\n if (op.value) {\n if (definition.type !== op.value.type) {\n Debug.assertPolymorphicType(relationship.identifier, definition, op.value, graph.store);\n graph.registerPolymorphicType(definition.type, op.value.type);\n }\n addToInverse(graph, op.value, definition.inverseKey, op.record, isRemote);\n }\n if (isRemote) {\n const {\n localState,\n remoteState\n } = relationship;\n if (localState && isNew(localState) && !remoteState) {\n return;\n }\n if (localState !== remoteState) {\n relationship.localState = remoteState;\n relationship.notifyBelongsToChange();\n }\n } else {\n relationship.notifyBelongsToChange();\n }\n }\n\n /*\n This method normalizes a link to an \"links object\". If the passed link is\n already an object it's returned without any modifications.\n\n See http://jsonapi.org/format/#document-links for more information.\n */\n function _normalizeLink(link) {\n switch (typeof link) {\n case 'object':\n return link;\n case 'string':\n return {\n href: link\n };\n }\n }\n\n /*\n Updates the \"canonical\" or \"remote\" state of a relationship, replacing any existing\n state and blowing away any local changes (excepting new records).\n */\n function updateRelationshipOperation(graph, op) {\n const relationship = graph.get(op.record, op.field);\n (!(isHasMany(relationship) || isBelongsTo(relationship)) && debug.assert(`Cannot update an implicit relationship`, isHasMany(relationship) || isBelongsTo(relationship)));\n const {\n definition,\n state,\n identifier\n } = relationship;\n const {\n isCollection\n } = definition;\n const payload = op.value;\n let hasRelationshipDataProperty = false;\n let hasUpdatedLink = false;\n if (payload.meta) {\n relationship.meta = payload.meta;\n }\n if (payload.data !== undefined) {\n hasRelationshipDataProperty = true;\n if (isCollection) {\n // TODO deprecate this case. We\n // have tests saying we support it.\n if (payload.data === null) {\n payload.data = [];\n }\n (!(Array.isArray(payload.data)) && debug.assert(`Expected an array`, Array.isArray(payload.data)));\n graph.update({\n op: 'replaceRelatedRecords',\n record: identifier,\n field: op.field,\n value: payload.data.map(i => graph.store.identifierCache.getOrCreateRecordIdentifier(i))\n }, true);\n } else {\n graph.update({\n op: 'replaceRelatedRecord',\n record: identifier,\n field: op.field,\n value: payload.data ? graph.store.identifierCache.getOrCreateRecordIdentifier(payload.data) : null\n }, true);\n }\n } else if (definition.isAsync === false && !state.hasReceivedData) {\n hasRelationshipDataProperty = true;\n if (isCollection) {\n graph.update({\n op: 'replaceRelatedRecords',\n record: identifier,\n field: op.field,\n value: []\n }, true);\n } else {\n graph.update({\n op: 'replaceRelatedRecord',\n record: identifier,\n field: op.field,\n value: null\n }, true);\n }\n }\n if (payload.links) {\n let originalLinks = relationship.links;\n relationship.links = payload.links;\n if (payload.links.related) {\n let relatedLink = _normalizeLink(payload.links.related);\n let currentLink = originalLinks && originalLinks.related ? _normalizeLink(originalLinks.related) : null;\n let currentLinkHref = currentLink ? currentLink.href : null;\n if (relatedLink && relatedLink.href && relatedLink.href !== currentLinkHref) {\n (debug.warn(`You pushed a record of type '${identifier.type}' with a relationship '${definition.key}' configured as 'async: false'. You've included a link but no primary data, this may be an error in your payload. EmberData will treat this relationship as known-to-be-empty.`, definition.isAsync || state.hasReceivedData, {\n id: 'ds.store.push-link-for-sync-relationship'\n }));\n (!(typeof relatedLink.href === 'string' || relatedLink.href === null) && debug.assert(`You have pushed a record of type '${identifier.type}' with '${definition.key}' as a link, but the value of that link is not a string.`, typeof relatedLink.href === 'string' || relatedLink.href === null));\n hasUpdatedLink = true;\n }\n }\n }\n\n /*\n Data being pushed into the relationship might contain only data or links,\n or a combination of both.\n \n IF contains only data\n IF contains both links and data\n state.isEmpty -> true if is empty array (has-many) or is null (belongs-to)\n state.hasReceivedData -> true\n hasDematerializedInverse -> false\n state.isStale -> false\n allInverseRecordsAreLoaded -> run-check-to-determine\n \n IF contains only links\n state.isStale -> true\n */\n relationship.state.hasFailedLoadAttempt = false;\n if (hasRelationshipDataProperty) {\n let relationshipIsEmpty = payload.data === null || Array.isArray(payload.data) && payload.data.length === 0;\n\n // we don't need to notify here as the update op we pushed in above will notify once\n // membership is in the correct state.\n relationship.state.hasReceivedData = true;\n relationship.state.isStale = false;\n relationship.state.hasDematerializedInverse = false;\n relationship.state.isEmpty = relationshipIsEmpty;\n } else if (hasUpdatedLink) {\n // only notify stale if we have not previously received membership data.\n // within this same transaction\n // this prevents refetching when only one side of the relationship in the\n // payload contains the info while the other side contains just a link\n // this only works when the side with just a link is a belongsTo, as we\n // don't know if a hasMany has full information or not.\n // see #7049 for context.\n if (isCollection || !relationship.state.hasReceivedData || relationship.transactionRef === 0) {\n relationship.state.isStale = true;\n if (isHasMany(relationship)) {\n relationship.notifyHasManyChange();\n } else {\n relationship.notifyBelongsToChange();\n }\n } else {\n relationship.state.isStale = false;\n }\n }\n }\n\n const Graphs = new Private.WeakCache('graph' );\n Graphs._generator = wrapper => {\n const graph = new Graph(wrapper);\n\n // in DEBUG we attach the graph to the main store for improved debuggability\n {\n Graphs.set(wrapper._store, graph);\n }\n return graph;\n };\n function isStore(maybeStore) {\n return maybeStore._storeWrapper !== undefined;\n }\n function getWrapper(store) {\n return isStore(store) ? store._storeWrapper : store;\n }\n function peekGraph(store) {\n return Graphs.get(getWrapper(store));\n }\n function graphFor(store) {\n return Graphs.lookup(getWrapper(store));\n }\n\n /*\n * Graph acts as the cache for relationship data. It allows for\n * us to ask about and update relationships for a given Identifier\n * without requiring other objects for that Identifier to be\n * instantiated (such as `InternalModel`, `RecordData` or a `Record`)\n *\n * This also allows for us to make more substantive changes to relationships\n * with increasingly minor alterations to other portions of the internals\n * over time.\n *\n * The graph is made up of nodes and edges. Each unique identifier gets\n * its own node, which is a dictionary with a list of that node's edges\n * (or connections) to other nodes. In `Model` terms, a node represents a\n * record instance, with each key (an edge) in the dictionary correlating\n * to either a `hasMany` or `belongsTo` field on that record instance.\n *\n * The value for each key, or `edge` is the identifier(s) the node relates\n * to in the graph from that key.\n */\n class Graph {\n constructor(store) {\n this._definitionCache = Object.create(null);\n this._potentialPolymorphicTypes = Object.create(null);\n this.identifiers = new Map();\n this.store = store;\n this._willSyncRemote = false;\n this._willSyncLocal = false;\n this._pushedUpdates = {\n belongsTo: [],\n hasMany: [],\n deletions: []\n };\n this._updatedRelationships = new Set();\n this._transaction = null;\n }\n has(identifier, propertyName) {\n let relationships = this.identifiers.get(identifier);\n if (!relationships) {\n return false;\n }\n return relationships[propertyName] !== undefined;\n }\n get(identifier, propertyName) {\n (!(propertyName) && debug.assert(`expected propertyName`, propertyName));\n let relationships = this.identifiers.get(identifier);\n if (!relationships) {\n relationships = Object.create(null);\n this.identifiers.set(identifier, relationships);\n }\n let relationship = relationships[propertyName];\n if (!relationship) {\n const info = upgradeDefinition(this, identifier, propertyName);\n (!(info !== null) && debug.assert(`Could not determine relationship information for ${identifier.type}.${propertyName}`, info !== null));\n const meta = isLHS(info, identifier.type, propertyName) ? info.lhs_definition : info.rhs_definition;\n const Klass = meta.kind === 'hasMany' ? ManyRelationship : meta.kind === 'belongsTo' ? BelongsToRelationship : ImplicitRelationship;\n relationship = relationships[propertyName] = new Klass(this, meta, identifier);\n }\n return relationship;\n }\n\n /*\n * Allows for the graph to dynamically discover polymorphic connections\n * without needing to walk prototype chains.\n *\n * Used by edges when an added `type` does not match the expected `type`\n * for that edge.\n *\n * Currently we assert before calling this. For a public API we will want\n * to call out to the schema manager to ask if we should consider these\n * types as equivalent for a given relationship.\n */\n registerPolymorphicType(type1, type2) {\n const typeCache = this._potentialPolymorphicTypes;\n let t1 = typeCache[type1];\n if (!t1) {\n t1 = typeCache[type1] = Object.create(null);\n }\n t1[type2] = true;\n let t2 = typeCache[type2];\n if (!t2) {\n t2 = typeCache[type2] = Object.create(null);\n }\n t2[type1] = true;\n }\n\n /*\n TODO move this comment somewhere else\n implicit relationships are relationships which have not been declared but the inverse side exists on\n another record somewhere\n For example if there was:\n ```app/models/comment.js\n import Model, { attr } from '@ember-data/model';\n export default class Comment extends Model {\n @attr text;\n }\n ```\n and there is also:\n ```app/models/post.js\n import Model, { attr, hasMany } from '@ember-data/model';\n export default class Post extends Model {\n @attr title;\n @hasMany('comment') comments;\n }\n ```\n Then we would have a implicit 'post' relationship for the comment record in order\n to be do things like remove the comment from the post if the comment were to be deleted.\n */\n\n isReleasable(identifier) {\n const relationships = this.identifiers.get(identifier);\n if (!relationships) {\n return true;\n }\n const keys = Object.keys(relationships);\n for (let i = 0; i < keys.length; i++) {\n const relationship = relationships[keys[i]];\n (!(relationship) && debug.assert(`Expected a relationship`, relationship));\n if (relationship.definition.inverseIsAsync) {\n return false;\n }\n }\n return true;\n }\n unload(identifier) {\n const relationships = this.identifiers.get(identifier);\n if (relationships) {\n // cleans up the graph but retains some nodes\n // to allow for rematerialization\n Object.keys(relationships).forEach(key => {\n let rel = relationships[key];\n destroyRelationship(rel);\n if (isImplicit(rel)) {\n delete relationships[key];\n }\n });\n }\n }\n remove(identifier) {\n this.unload(identifier);\n this.identifiers.delete(identifier);\n }\n\n /*\n * Remote state changes\n */\n push(op) {\n if (op.op === 'deleteRecord') {\n this._pushedUpdates.deletions.push(op);\n } else if (op.op === 'replaceRelatedRecord') {\n this._pushedUpdates.belongsTo.push(op);\n } else {\n const relationship = this.get(op.record, op.field);\n (!(!relationship.definition.isImplicit) && debug.assert(`Cannot push a remote update for an implicit relationship`, !relationship.definition.isImplicit));\n this._pushedUpdates[relationship.definition.kind].push(op);\n }\n if (!this._willSyncRemote) {\n this._willSyncRemote = true;\n const backburner = this.store._store._backburner;\n backburner.schedule('coalesce', this, this._flushRemoteQueue);\n }\n }\n\n /*\n * Local state changes\n */\n\n update(op, isRemote = false) {\n (!(op.op === 'deleteRecord' || !isImplicit(this.get(op.record, op.field))) && debug.assert(`Cannot update an implicit relationship`, op.op === 'deleteRecord' || !isImplicit(this.get(op.record, op.field))));\n switch (op.op) {\n case 'updateRelationship':\n (!(isRemote) && debug.assert(`Can only perform the operation updateRelationship on remote state`, isRemote));\n {\n // in debug, assert payload validity eagerly\n // TODO add deprecations/assertion here for duplicates\n assertValidRelationshipPayload(this, op);\n }\n updateRelationshipOperation(this, op);\n break;\n case 'deleteRecord':\n {\n (!(isRemote) && debug.assert(`Can only perform the operation deleteRelationship on remote state`, isRemote));\n const identifier = op.record;\n const relationships = this.identifiers.get(identifier);\n if (relationships) {\n Object.keys(relationships).forEach(key => {\n const rel = relationships[key];\n // works together with the has check\n delete relationships[key];\n removeCompletelyFromInverse(rel);\n });\n this.identifiers.delete(identifier);\n }\n break;\n }\n case 'replaceRelatedRecord':\n replaceRelatedRecord(this, op, isRemote);\n break;\n case 'addToRelatedRecords':\n addToRelatedRecords(this, op, isRemote);\n break;\n case 'removeFromRelatedRecords':\n removeFromRelatedRecords(this, op, isRemote);\n break;\n case 'replaceRelatedRecords':\n replaceRelatedRecords(this, op, isRemote);\n break;\n default:\n (debug.assert(`No local relationship update operation exists for '${op.op}'`));\n }\n }\n _scheduleLocalSync(relationship) {\n this._updatedRelationships.add(relationship);\n if (!this._willSyncLocal) {\n this._willSyncLocal = true;\n const backburner = this.store._store._backburner;\n backburner.schedule('sync', this, this._flushLocalQueue);\n }\n }\n _flushRemoteQueue() {\n if (!this._willSyncRemote) {\n return;\n }\n this._transaction = new Set();\n this._willSyncRemote = false;\n const {\n deletions,\n hasMany,\n belongsTo\n } = this._pushedUpdates;\n this._pushedUpdates.deletions = [];\n this._pushedUpdates.hasMany = [];\n this._pushedUpdates.belongsTo = [];\n for (let i = 0; i < deletions.length; i++) {\n this.update(deletions[i], true);\n }\n for (let i = 0; i < hasMany.length; i++) {\n this.update(hasMany[i], true);\n }\n for (let i = 0; i < belongsTo.length; i++) {\n this.update(belongsTo[i], true);\n }\n this._finalize();\n }\n _addToTransaction(relationship) {\n (!(this._transaction !== null) && debug.assert(`expected a transaction`, this._transaction !== null));\n relationship.transactionRef++;\n this._transaction.add(relationship);\n }\n _finalize() {\n if (this._transaction) {\n this._transaction.forEach(v => v.transactionRef = 0);\n this._transaction = null;\n }\n }\n _flushLocalQueue() {\n if (!this._willSyncLocal) {\n return;\n }\n this._willSyncLocal = false;\n let updated = this._updatedRelationships;\n this._updatedRelationships = new Set();\n updated.forEach(syncRemoteToLocal);\n }\n willDestroy() {\n this.identifiers.clear();\n this.store = null;\n }\n destroy() {\n Graphs.delete(this.store);\n {\n Graphs.delete(this.store._store);\n }\n }\n }\n\n // Handle dematerialization for relationship `rel`. In all cases, notify the\n // relationship of the dematerialization: this is done so the relationship can\n // notify its inverse which needs to update state\n //\n // If the inverse is sync, unloading this record is treated as a client-side\n // delete, so we remove the inverse records from this relationship to\n // disconnect the graph. Because it's not async, we don't need to keep around\n // the internalModel as an id-wrapper for references and because the graph is\n // disconnected we can actually destroy the internalModel when checking for\n // orphaned models.\n function destroyRelationship(rel) {\n if (isImplicit(rel)) {\n if (rel.graph.isReleasable(rel.identifier)) {\n removeCompletelyFromInverse(rel);\n }\n return;\n }\n rel.recordDataDidDematerialize();\n if (!rel.definition.inverseIsImplicit && !rel.definition.inverseIsAsync) {\n rel.state.isStale = true;\n rel.clear();\n\n // necessary to clear relationships in the ui from dematerialized records\n // hasMany is managed by InternalModel which calls `retreiveLatest` after\n // dematerializing the recordData instance.\n // but sync belongsTo require this since they don't have a proxy to update.\n // so we have to notify so it will \"update\" to null.\n // we should discuss whether we still care about this, probably fine to just\n // leave the ui relationship populated since the record is destroyed and\n // internally we've fully cleaned up.\n if (!rel.definition.isAsync) {\n if (isBelongsTo(rel)) {\n rel.notifyBelongsToChange();\n } else {\n rel.notifyHasManyChange();\n }\n }\n }\n }\n function removeCompletelyFromInverse(relationship) {\n // we actually want a union of members and canonicalMembers\n // they should be disjoint but currently are not due to a bug\n const seen = Object.create(null);\n const {\n identifier\n } = relationship;\n const {\n inverseKey\n } = relationship.definition;\n const unload = inverseIdentifier => {\n const id = inverseIdentifier.lid;\n if (seen[id] === undefined) {\n if (relationship.graph.has(inverseIdentifier, inverseKey)) {\n relationship.graph.get(inverseIdentifier, inverseKey).removeCompletelyFromOwn(identifier);\n }\n seen[id] = true;\n }\n };\n if (isBelongsTo(relationship)) {\n if (relationship.localState) {\n unload(relationship.localState);\n }\n if (relationship.remoteState) {\n unload(relationship.remoteState);\n }\n if (!relationship.definition.isAsync) {\n relationship.clear();\n }\n relationship.localState = null;\n } else if (isHasMany(relationship)) {\n relationship.members.forEach(unload);\n relationship.canonicalMembers.forEach(unload);\n if (!relationship.definition.isAsync) {\n relationship.clear();\n relationship.notifyHasManyChange();\n }\n } else {\n relationship.members.forEach(unload);\n relationship.canonicalMembers.forEach(unload);\n relationship.clear();\n }\n }\n\n let nextBfsId = 1;\n const EMPTY_ITERATOR = {\n iterator() {\n return {\n next() {\n return {\n done: true,\n value: undefined\n };\n }\n };\n }\n };\n\n /**\n The default cache implementation used by ember-data. The cache\n is configurable and using a different implementation can be\n achieved by implementing the store's createRecordDataFor hook.\n\n @class RecordDataDefault\n @public\n */\n class RecordDataDefault {\n constructor(identifier, storeWrapper) {\n /*\n Iterates over the set of internal models reachable from `this` across exactly one\n relationship.\n */\n this._directlyRelatedRecordDatasIterable = () => {\n const graph = graphFor(this.storeWrapper);\n const initializedRelationships = graph.identifiers.get(this.identifier);\n if (!initializedRelationships) {\n return EMPTY_ITERATOR;\n }\n const initializedRelationshipsArr = Object.keys(initializedRelationships).map(key => initializedRelationships[key]).filter(rel => {\n return !isImplicit(rel);\n });\n let i = 0;\n let j = 0;\n let k = 0;\n const findNext = () => {\n while (i < initializedRelationshipsArr.length) {\n while (j < 2) {\n let members = j === 0 ? getLocalState(initializedRelationshipsArr[i]) : getRemoteState(initializedRelationshipsArr[i]);\n while (k < members.length) {\n let member = members[k++];\n if (member !== null) {\n // TODO this can cause materialization\n // do something to avoid that\n return Private.recordDataFor(member);\n }\n }\n k = 0;\n j++;\n }\n j = 0;\n i++;\n }\n return undefined;\n };\n return {\n iterator() {\n return {\n next: () => {\n const value = findNext();\n return {\n value,\n done: value === undefined\n };\n }\n };\n }\n };\n };\n this.modelName = identifier.type;\n this.clientId = identifier.lid;\n this.id = identifier.id;\n this.identifier = identifier;\n this.storeWrapper = storeWrapper;\n this.isDestroyed = false;\n this._isNew = false;\n this._isDeleted = false;\n // Used during the mark phase of unloading to avoid checking the same internal\n // model twice in the same scan\n this._bfsId = 0;\n this.reset();\n }\n\n // PUBLIC API\n getResourceIdentifier() {\n return this.identifier;\n }\n pushData(data, calculateChange) {\n let changedKeys;\n if (this._isNew) {\n this._isNew = false;\n this.notifyStateChange();\n }\n if (calculateChange) {\n changedKeys = this._changedKeys(data.attributes);\n }\n Object.assign(this._data, data.attributes);\n if (this.__attributes) {\n // only do if we have attribute changes\n this._updateChangedAttributes();\n }\n if (data.relationships) {\n this._setupRelationships(data);\n }\n if (data.id) {\n if (!this.id) {\n this.id = coerceId(data.id);\n }\n }\n return changedKeys;\n }\n willCommit() {\n this._inFlightAttributes = this._attributes;\n this._attributes = null;\n }\n hasChangedAttributes() {\n return this.__attributes !== null && Object.keys(this.__attributes).length > 0;\n }\n _clearErrors() {\n if (this._errors) {\n this._errors = undefined;\n this.storeWrapper.notifyErrorsChange(this.modelName, this.id, this.clientId);\n }\n }\n getErrors() {\n let errors = this._errors || [];\n return errors;\n }\n\n // this is a hack bc we don't have access to the state machine\n // and relationships need this info and @runspired didn't see\n // how to get it just yet from storeWrapper.\n isEmpty() {\n return this.__attributes === null && this.__inFlightAttributes === null && this.__data === null;\n }\n deleteRecord() {\n this._isDeleted = true;\n this.notifyStateChange();\n }\n isDeleted() {\n return this._isDeleted;\n }\n setIsDeleted(isDeleted) {\n this._isDeleted = isDeleted;\n if (this._isNew) {\n this._deletionConfirmed();\n }\n this.notifyStateChange();\n }\n isDeletionCommitted() {\n return this._isDeletionCommited;\n }\n reset() {\n this.__attributes = null;\n this.__inFlightAttributes = null;\n this.__data = null;\n this._errors = undefined;\n }\n _setupRelationships(data) {\n // TODO @runspired iterating by definitions instead of by payload keys\n // allows relationship payloads to be ignored silently if no relationship\n // definition exists. Ensure there's a test for this and then consider\n // moving this to an assertion. This check should possibly live in the graph.\n let relationships = this.storeWrapper.relationshipsDefinitionFor(this.modelName);\n let keys = Object.keys(relationships);\n for (let i = 0; i < keys.length; i++) {\n let relationshipName = keys[i];\n if (!data.relationships[relationshipName]) {\n continue;\n }\n let relationshipData = data.relationships[relationshipName];\n graphFor(this.storeWrapper).push({\n op: 'updateRelationship',\n record: this.identifier,\n field: relationshipName,\n value: relationshipData\n });\n }\n }\n\n /**\n Checks if the attributes which are considered as changed are still\n different to the state which is acknowledged by the server.\n This method is needed when data for the internal model is pushed and the\n pushed data might acknowledge dirty attributes as confirmed.\n @method updateChangedAttributes\n @private\n */\n _updateChangedAttributes() {\n let changedAttributes = this.changedAttributes();\n let changedAttributeNames = Object.keys(changedAttributes);\n let attrs = this._attributes;\n for (let i = 0, length = changedAttributeNames.length; i < length; i++) {\n let attribute = changedAttributeNames[i];\n let data = changedAttributes[attribute];\n let oldData = data[0];\n let newData = data[1];\n if (oldData === newData) {\n delete attrs[attribute];\n }\n }\n }\n\n /**\n Returns an object, whose keys are changed properties, and value is an\n [oldProp, newProp] array.\n @method changedAttributes\n @private\n */\n changedAttributes() {\n let oldData = this._data;\n let currentData = this._attributes;\n let inFlightData = this._inFlightAttributes;\n let newData = {\n ...inFlightData,\n ...currentData\n };\n let diffData = Object.create(null);\n let newDataKeys = Object.keys(newData);\n for (let i = 0, length = newDataKeys.length; i < length; i++) {\n let key = newDataKeys[i];\n diffData[key] = [oldData[key], newData[key]];\n }\n return diffData;\n }\n isNew() {\n return this._isNew;\n }\n rollbackAttributes() {\n let dirtyKeys;\n this._isDeleted = false;\n if (this.hasChangedAttributes()) {\n dirtyKeys = Object.keys(this._attributes);\n this._attributes = null;\n }\n if (this.isNew()) {\n this.removeFromInverseRelationships();\n this._isDeleted = true;\n this._isNew = false;\n }\n this._inFlightAttributes = null;\n this._clearErrors();\n this.notifyStateChange();\n return dirtyKeys;\n }\n _deletionConfirmed() {\n this.removeFromInverseRelationships();\n }\n didCommit(data) {\n if (this._isDeleted) {\n this._deletionConfirmed();\n this._isDeletionCommited = true;\n }\n this._isNew = false;\n let newCanonicalAttributes;\n if (data) {\n if (data.id) {\n // didCommit provided an ID, notify the store of it\n this.storeWrapper.setRecordId(this.modelName, data.id, this.clientId);\n this.id = coerceId(data.id);\n }\n if (data.relationships) {\n this._setupRelationships(data);\n }\n newCanonicalAttributes = data.attributes;\n }\n let changedKeys = this._changedKeys(newCanonicalAttributes);\n Object.assign(this._data, this.__inFlightAttributes, newCanonicalAttributes);\n this._inFlightAttributes = null;\n this._updateChangedAttributes();\n this._clearErrors();\n this.notifyStateChange();\n return changedKeys;\n }\n notifyStateChange() {\n this.storeWrapper.notifyStateChange(this.modelName, this.id, this.clientId);\n }\n\n // get ResourceIdentifiers for \"current state\"\n getHasMany(key) {\n return graphFor(this.storeWrapper).get(this.identifier, key).getData();\n }\n\n // set a new \"current state\" via ResourceIdentifiers\n setDirtyHasMany(key, recordDatas) {\n graphFor(this.storeWrapper).update({\n op: 'replaceRelatedRecords',\n record: this.identifier,\n field: key,\n value: recordDatas.map(Private.recordIdentifierFor)\n });\n }\n\n // append to \"current state\" via RecordDatas\n addToHasMany(key, recordDatas, idx) {\n graphFor(this.storeWrapper).update({\n op: 'addToRelatedRecords',\n record: this.identifier,\n field: key,\n value: recordDatas.map(Private.recordIdentifierFor),\n index: idx\n });\n }\n\n // remove from \"current state\" via RecordDatas\n removeFromHasMany(key, recordDatas) {\n graphFor(this.storeWrapper).update({\n op: 'removeFromRelatedRecords',\n record: this.identifier,\n field: key,\n value: recordDatas.map(Private.recordIdentifierFor)\n });\n }\n commitWasRejected(identifier, errors) {\n let keys = Object.keys(this._inFlightAttributes);\n if (keys.length > 0) {\n let attrs = this._attributes;\n for (let i = 0; i < keys.length; i++) {\n if (attrs[keys[i]] === undefined) {\n attrs[keys[i]] = this._inFlightAttributes[keys[i]];\n }\n }\n }\n this._inFlightAttributes = null;\n if (errors) {\n this._errors = errors;\n }\n this.storeWrapper.notifyErrorsChange(this.modelName, this.id, this.clientId);\n }\n getBelongsTo(key) {\n return graphFor(this.storeWrapper).get(this.identifier, key).getData();\n }\n setDirtyBelongsTo(key, recordData) {\n graphFor(this.storeWrapper).update({\n op: 'replaceRelatedRecord',\n record: this.identifier,\n field: key,\n value: recordData ? Private.recordIdentifierFor(recordData) : null\n });\n }\n setDirtyAttribute(key, value) {\n let originalValue;\n // Add the new value to the changed attributes hash\n this._attributes[key] = value;\n if (key in this._inFlightAttributes) {\n originalValue = this._inFlightAttributes[key];\n } else {\n originalValue = this._data[key];\n }\n // If we went back to our original value, we shouldn't keep the attribute around anymore\n if (value === originalValue) {\n delete this._attributes[key];\n }\n }\n\n // internal set coming from the model\n __setId(id) {\n if (this.id !== id) {\n this.id = id;\n }\n }\n getAttr(key) {\n if (key in this._attributes) {\n return this._attributes[key];\n } else if (key in this._inFlightAttributes) {\n return this._inFlightAttributes[key];\n } else {\n return this._data[key];\n }\n }\n hasAttr(key) {\n return key in this._attributes || key in this._inFlightAttributes || key in this._data;\n }\n unloadRecord() {\n if (this.isDestroyed) {\n return;\n }\n graphFor(this.storeWrapper).unload(this.identifier);\n this.reset();\n if (!this._scheduledDestroy) {\n this._scheduledDestroy = runloop._backburner.schedule('destroy', this, '_cleanupOrphanedRecordDatas');\n }\n }\n _cleanupOrphanedRecordDatas() {\n let relatedRecordDatas = this._allRelatedRecordDatas();\n if (areAllModelsUnloaded(relatedRecordDatas)) {\n // we don't have a backburner queue yet since\n // we scheduled this into ember's destroy\n // disconnectRecord called from destroy will teardown\n // relationships. We do this to queue that.\n this.storeWrapper._store._backburner.join(() => {\n for (let i = 0; i < relatedRecordDatas.length; ++i) {\n let recordData = relatedRecordDatas[i];\n if (!recordData.isDestroyed) {\n // TODO @runspired we do not currently destroy RecordData instances *except* via this relationship\n // traversal. This seems like an oversight since the store should be able to notify destroy.\n Private.removeRecordDataFor(recordData.identifier);\n recordData.destroy();\n }\n }\n });\n }\n this._scheduledDestroy = null;\n }\n destroy() {\n this.isDestroyed = true;\n this.storeWrapper.disconnectRecord(this.modelName, this.id, this.clientId);\n }\n isRecordInUse() {\n return this.storeWrapper.isRecordInUse(this.modelName, this.id, this.clientId);\n }\n /*\n Computes the set of internal models reachable from this internal model.\n Reachability is determined over the relationship graph (ie a graph where\n nodes are internal models and edges are belongs to or has many\n relationships).\n Returns an array including `this` and all internal models reachable\n from `this`.\n */\n _allRelatedRecordDatas() {\n let array = [];\n let queue = [];\n let bfsId = nextBfsId++;\n queue.push(this);\n this._bfsId = bfsId;\n while (queue.length > 0) {\n let node = queue.shift();\n array.push(node);\n const iterator = this._directlyRelatedRecordDatasIterable().iterator();\n for (let obj = iterator.next(); !obj.done; obj = iterator.next()) {\n const recordData = obj.value;\n if (recordData && recordData instanceof RecordDataDefault) {\n (!(recordData._bfsId <= bfsId) && debug.assert('Internal Error: seen a future bfs iteration', recordData._bfsId <= bfsId));\n if (recordData._bfsId < bfsId) {\n queue.push(recordData);\n recordData._bfsId = bfsId;\n }\n }\n }\n }\n return array;\n }\n isAttrDirty(key) {\n if (this._attributes[key] === undefined) {\n return false;\n }\n let originalValue;\n if (this._inFlightAttributes[key] !== undefined) {\n originalValue = this._inFlightAttributes[key];\n } else {\n originalValue = this._data[key];\n }\n return originalValue !== this._attributes[key];\n }\n get _attributes() {\n if (this.__attributes === null) {\n this.__attributes = Object.create(null);\n }\n return this.__attributes;\n }\n set _attributes(v) {\n this.__attributes = v;\n }\n get _data() {\n if (this.__data === null) {\n this.__data = Object.create(null);\n }\n return this.__data;\n }\n set _data(v) {\n this.__data = v;\n }\n get _inFlightAttributes() {\n if (this.__inFlightAttributes === null) {\n this.__inFlightAttributes = Object.create(null);\n }\n return this.__inFlightAttributes;\n }\n set _inFlightAttributes(v) {\n this.__inFlightAttributes = v;\n }\n\n /**\n * Receives options passed to `store.createRecord` and is given the opportunity\n * to handle them.\n *\n * The return value is an object of options to pass to `Record.create()`\n *\n * @name _initRecordCreateOptions\n * @param options\n * @private\n */\n _initRecordCreateOptions(options) {\n let createOptions = {};\n if (options !== undefined) {\n const {\n modelName,\n storeWrapper,\n identifier\n } = this;\n let attributeDefs = storeWrapper.attributesDefinitionFor(modelName);\n let relationshipDefs = storeWrapper.relationshipsDefinitionFor(modelName);\n const graph = graphFor(storeWrapper);\n let propertyNames = Object.keys(options);\n for (let i = 0; i < propertyNames.length; i++) {\n let name = propertyNames[i];\n let propertyValue = options[name];\n if (name === 'id') {\n this.id = propertyValue;\n continue;\n }\n let fieldType = relationshipDefs[name] || attributeDefs[name];\n let kind = fieldType !== undefined ? fieldType.kind : null;\n let relationship;\n switch (kind) {\n case 'attribute':\n this.setDirtyAttribute(name, propertyValue);\n break;\n case 'belongsTo':\n this.setDirtyBelongsTo(name, propertyValue);\n relationship = graph.get(identifier, name);\n relationship.state.hasReceivedData = true;\n relationship.state.isEmpty = false;\n break;\n case 'hasMany':\n this.setDirtyHasMany(name, propertyValue);\n relationship = graph.get(identifier, name);\n relationship.state.hasReceivedData = true;\n relationship.state.isEmpty = false;\n break;\n default:\n // reflect back (pass-thru) unknown properties\n createOptions[name] = propertyValue;\n }\n }\n }\n return createOptions;\n }\n\n /*\n TODO IGOR AND DAVID this shouldn't be public\n This method should only be called by records in the `isNew()` state OR once the record\n has been deleted and that deletion has been persisted.\n It will remove this record from any associated relationships.\n If `isNew` is true (default false), it will also completely reset all\n relationships to an empty state as well.\n @method removeFromInverseRelationships\n @param {Boolean} isNew whether to unload from the `isNew` perspective\n @private\n */\n removeFromInverseRelationships() {\n graphFor(this.storeWrapper).push({\n op: 'deleteRecord',\n record: this.identifier,\n isNew: this.isNew()\n });\n }\n clientDidCreate() {\n this._isNew = true;\n }\n\n /*\n Ember Data has 3 buckets for storing the value of an attribute on an internalModel.\n `_data` holds all of the attributes that have been acknowledged by\n a backend via the adapter. When rollbackAttributes is called on a model all\n attributes will revert to the record's state in `_data`.\n `_attributes` holds any change the user has made to an attribute\n that has not been acknowledged by the adapter. Any values in\n `_attributes` are have priority over values in `_data`.\n `_inFlightAttributes`. When a record is being synced with the\n backend the values in `_attributes` are copied to\n `_inFlightAttributes`. This way if the backend acknowledges the\n save but does not return the new state Ember Data can copy the\n values from `_inFlightAttributes` to `_data`. Without having to\n worry about changes made to `_attributes` while the save was\n happenign.\n Changed keys builds a list of all of the values that may have been\n changed by the backend after a successful save.\n It does this by iterating over each key, value pair in the payload\n returned from the server after a save. If the `key` is found in\n `_attributes` then the user has a local changed to the attribute\n that has not been synced with the server and the key is not\n included in the list of changed keys.\n \n If the value, for a key differs from the value in what Ember Data\n believes to be the truth about the backend state (A merger of the\n `_data` and `_inFlightAttributes` objects where\n `_inFlightAttributes` has priority) then that means the backend\n has updated the value and the key is added to the list of changed\n keys.\n @method _changedKeys\n @private\n */\n /*\n TODO IGOR DAVID\n There seems to be a potential bug here, where we will return keys that are not\n in the schema\n */\n _changedKeys(updates) {\n let changedKeys = [];\n if (updates) {\n let original, i, value, key;\n let keys = Object.keys(updates);\n let length = keys.length;\n let hasAttrs = this.hasChangedAttributes();\n let attrs;\n if (hasAttrs) {\n attrs = this._attributes;\n }\n original = Object.assign(Object.create(null), this._data, this.__inFlightAttributes);\n for (i = 0; i < length; i++) {\n key = keys[i];\n value = updates[key];\n\n // A value in _attributes means the user has a local change to\n // this attributes. We never override this value when merging\n // updates from the backend so we should not sent a change\n // notification if the server value differs from the original.\n if (hasAttrs === true && attrs[key] !== undefined) {\n continue;\n }\n if (!utils.isEqual(original[key], value)) {\n changedKeys.push(key);\n }\n }\n }\n return changedKeys;\n }\n toString() {\n return `<${this.modelName}:${this.id}>`;\n }\n }\n function areAllModelsUnloaded(recordDatas) {\n for (let i = 0; i < recordDatas.length; ++i) {\n if (recordDatas[i].isRecordInUse()) {\n return false;\n }\n }\n return true;\n }\n function getLocalState(rel) {\n if (rel.definition.kind === 'belongsTo') {\n return rel.localState ? [rel.localState] : [];\n }\n return rel.currentState;\n }\n function getRemoteState(rel) {\n if (rel.definition.kind === 'belongsTo') {\n return rel.remoteState ? [rel.remoteState] : [];\n }\n return rel.canonicalState;\n }\n\n exports.BelongsToRelationship = BelongsToRelationship;\n exports.ManyRelationship = ManyRelationship;\n exports.RecordData = RecordDataDefault;\n exports.Relationship = ImplicitRelationship;\n exports.graphFor = graphFor;\n exports.peekGraph = peekGraph;\n\n Object.defineProperty(exports, '__esModule', { value: true });\n\n}));\n","define('@ember-data/serializer/-private', ['exports', '@ember/array', '@ember/debug', '@ember/object', '@ember/object/mixin', '@ember/string', '@ember/utils'], (function (exports, array, debug, EmberObject, Mixin, string, utils) { 'use strict';\n\n function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }\n\n var EmberObject__default = /*#__PURE__*/_interopDefaultLegacy(EmberObject);\n var Mixin__default = /*#__PURE__*/_interopDefaultLegacy(Mixin);\n\n /**\n @module @ember-data/serializer/rest\n */\n\n /**\n ## Using Embedded Records\n\n `EmbeddedRecordsMixin` supports serializing embedded records.\n\n To set up embedded records, include the mixin when extending a serializer,\n then define and configure embedded (model) relationships.\n\n Note that embedded records will serialize with the serializer for their model instead of the serializer in which they are defined.\n\n Note also that this mixin does not work with JSONAPISerializer because the JSON:API specification does not describe how to format embedded resources.\n\n Below is an example of a per-type serializer (`post` type).\n\n ```app/serializers/post.js\n import RESTSerializer, { EmbeddedRecordsMixin } from '@ember-data/serializer/rest';\n\n export default class PostSerializer extends RESTSerializer.extend(EmbeddedRecordsMixin) {\n attrs = {\n author: { embedded: 'always' },\n comments: { serialize: 'ids' }\n }\n }\n ```\n Note that this use of `{ embedded: 'always' }` is unrelated to\n the `{ embedded: 'always' }` that is defined as an option on `attr` as part of\n defining a model while working with the `ActiveModelSerializer`. Nevertheless,\n using `{ embedded: 'always' }` as an option to `attr` is not a valid way to set up\n embedded records.\n\n The `attrs` option for a resource `{ embedded: 'always' }` is shorthand for:\n\n ```js\n {\n serialize: 'records',\n deserialize: 'records'\n }\n ```\n\n ### Configuring Attrs\n\n A resource's `attrs` option may be set to use `ids`, `records` or false for the\n `serialize` and `deserialize` settings.\n\n The `attrs` property can be set on the `ApplicationSerializer` or a per-type\n serializer.\n\n In the case where embedded JSON is expected while extracting a payload (reading)\n the setting is `deserialize: 'records'`, there is no need to use `ids` when\n extracting as that is the default behaviour without this mixin if you are using\n the vanilla `EmbeddedRecordsMixin`. Likewise, to embed JSON in the payload while\n serializing `serialize: 'records'` is the setting to use. There is an option of\n not embedding JSON in the serialized payload by using `serialize: 'ids'`. If you\n do not want the relationship sent at all, you can use `serialize: false`.\n\n\n ### EmbeddedRecordsMixin defaults\n If you do not overwrite `attrs` for a specific relationship, the `EmbeddedRecordsMixin`\n will behave in the following way:\n\n BelongsTo: `{ serialize: 'id', deserialize: 'id' }`\n HasMany: `{ serialize: false, deserialize: 'ids' }`\n\n ### Model Relationships\n\n Embedded records must have a model defined to be extracted and serialized. Note that\n when defining any relationships on your model such as `belongsTo` and `hasMany`, you\n should not both specify `async: true` and also indicate through the serializer's\n `attrs` attribute that the related model should be embedded for deserialization.\n If a model is declared embedded for deserialization (`embedded: 'always'` or `deserialize: 'records'`),\n then do not use `async: true`.\n\n To successfully extract and serialize embedded records the model relationships\n must be set up correctly. See the\n [defining relationships](https://guides.emberjs.com/current/models/relationships)\n section of the **Defining Models** guide page.\n\n Records without an `id` property are not considered embedded records, model\n instances must have an `id` property to be used with Ember Data.\n\n ### Example JSON payloads, Models and Serializers\n\n **When customizing a serializer it is important to grok what the customizations\n are. Please read the docs for the methods this mixin provides, in case you need\n to modify it to fit your specific needs.**\n\n For example, review the docs for each method of this mixin:\n * [normalize](/ember-data/release/classes/EmbeddedRecordsMixin/methods/normalize?anchor=normalize)\n * [serializeBelongsTo](/ember-data/release/classes/EmbeddedRecordsMixin/methods/serializeBelongsTo?anchor=serializeBelongsTo)\n * [serializeHasMany](/ember-data/release/classes/EmbeddedRecordsMixin/methods/serializeHasMany?anchor=serializeHasMany)\n\n @class EmbeddedRecordsMixin\n @public\n */\n var embeddedRecordsMixin = Mixin__default[\"default\"].create({\n /**\n Normalize the record and recursively normalize/extract all the embedded records\n while pushing them into the store as they are encountered\n A payload with an attr configured for embedded records needs to be extracted:\n ```js\n {\n \"post\": {\n \"id\": \"1\"\n \"title\": \"Rails is omakase\",\n \"comments\": [{\n \"id\": \"1\",\n \"body\": \"Rails is unagi\"\n }, {\n \"id\": \"2\",\n \"body\": \"Omakase O_o\"\n }]\n }\n }\n ```\n @method normalize\n @public\n @param {Model} typeClass\n @param {Object} hash to be normalized\n @param {String} prop the hash has been referenced by\n @return {Object} the normalized hash\n **/\n normalize(typeClass, hash, prop) {\n let normalizedHash = this._super(typeClass, hash, prop);\n return this._extractEmbeddedRecords(this, this.store, typeClass, normalizedHash);\n },\n keyForRelationship(key, typeClass, method) {\n if (method === 'serialize' && this.hasSerializeRecordsOption(key) || method === 'deserialize' && this.hasDeserializeRecordsOption(key)) {\n return this.keyForAttribute(key, method);\n } else {\n return this._super(key, typeClass, method) || key;\n }\n },\n /**\n Serialize `belongsTo` relationship when it is configured as an embedded object.\n This example of an author model belongs to a post model:\n ```js\n import Model, { attr, belongsTo } from '@ember-data/model';\n Post = Model.extend({\n title: attr('string'),\n body: attr('string'),\n author: belongsTo('author')\n });\n Author = Model.extend({\n name: attr('string'),\n post: belongsTo('post')\n });\n ```\n Use a custom (type) serializer for the post model to configure embedded author\n ```app/serializers/post.js\n import RESTSerializer, { EmbeddedRecordsMixin } from '@ember-data/serializer/rest';\n export default class PostSerializer extends RESTSerializer.extend(EmbeddedRecordsMixin) {\n attrs = {\n author: { embedded: 'always' }\n }\n }\n ```\n A payload with an attribute configured for embedded records can serialize\n the records together under the root attribute's payload:\n ```js\n {\n \"post\": {\n \"id\": \"1\"\n \"title\": \"Rails is omakase\",\n \"author\": {\n \"id\": \"2\"\n \"name\": \"dhh\"\n }\n }\n }\n ```\n @method serializeBelongsTo\n @public\n @param {Snapshot} snapshot\n @param {Object} json\n @param {Object} relationship\n */\n serializeBelongsTo(snapshot, json, relationship) {\n let attr = relationship.key;\n if (this.noSerializeOptionSpecified(attr)) {\n this._super(snapshot, json, relationship);\n return;\n }\n let includeIds = this.hasSerializeIdsOption(attr);\n let includeRecords = this.hasSerializeRecordsOption(attr);\n let embeddedSnapshot = snapshot.belongsTo(attr);\n if (includeIds) {\n let serializedKey = this._getMappedKey(relationship.key, snapshot.type);\n if (serializedKey === relationship.key && this.keyForRelationship) {\n serializedKey = this.keyForRelationship(relationship.key, relationship.kind, 'serialize');\n }\n if (!embeddedSnapshot) {\n json[serializedKey] = null;\n } else {\n json[serializedKey] = embeddedSnapshot.id;\n if (relationship.options.polymorphic) {\n this.serializePolymorphicType(snapshot, json, relationship);\n }\n }\n } else if (includeRecords) {\n this._serializeEmbeddedBelongsTo(snapshot, json, relationship);\n }\n },\n _serializeEmbeddedBelongsTo(snapshot, json, relationship) {\n let embeddedSnapshot = snapshot.belongsTo(relationship.key);\n let serializedKey = this._getMappedKey(relationship.key, snapshot.type);\n if (serializedKey === relationship.key && this.keyForRelationship) {\n serializedKey = this.keyForRelationship(relationship.key, relationship.kind, 'serialize');\n }\n if (!embeddedSnapshot) {\n json[serializedKey] = null;\n } else {\n json[serializedKey] = embeddedSnapshot.serialize({\n includeId: true\n });\n this.removeEmbeddedForeignKey(snapshot, embeddedSnapshot, relationship, json[serializedKey]);\n if (relationship.options.polymorphic) {\n this.serializePolymorphicType(snapshot, json, relationship);\n }\n }\n },\n /**\n Serializes `hasMany` relationships when it is configured as embedded objects.\n This example of a post model has many comments:\n ```js\n import Model, { attr, belongsTo, hasMany } from '@ember-data/model';\n Post = Model.extend({\n title: attr('string'),\n body: attr('string'),\n comments: hasMany('comment')\n });\n Comment = Model.extend({\n body: attr('string'),\n post: belongsTo('post')\n });\n ```\n Use a custom (type) serializer for the post model to configure embedded comments\n ```app/serializers/post.js\n import RESTSerializer, { EmbeddedRecordsMixin } from '@ember-data/serializer/rest';\n export default class PostSerializer extends RESTSerializer.extend(EmbeddedRecordsMixin) {\n attrs = {\n comments: { embedded: 'always' }\n }\n }\n ```\n A payload with an attribute configured for embedded records can serialize\n the records together under the root attribute's payload:\n ```js\n {\n \"post\": {\n \"id\": \"1\"\n \"title\": \"Rails is omakase\",\n \"body\": \"I want this for my ORM, I want that for my template language...\"\n \"comments\": [{\n \"id\": \"1\",\n \"body\": \"Rails is unagi\"\n }, {\n \"id\": \"2\",\n \"body\": \"Omakase O_o\"\n }]\n }\n }\n ```\n The attrs options object can use more specific instruction for extracting and\n serializing. When serializing, an option to embed `ids`, `ids-and-types` or `records` can be set.\n When extracting the only option is `records`.\n So `{ embedded: 'always' }` is shorthand for:\n `{ serialize: 'records', deserialize: 'records' }`\n To embed the `ids` for a related object (using a hasMany relationship):\n ```app/serializers/post.js\n import RESTSerializer, { EmbeddedRecordsMixin } from '@ember-data/serializer/rest';\n export default class PostSerializer extends RESTSerializer.extend(EmbeddedRecordsMixin) {\n attrs = {\n comments: { serialize: 'ids', deserialize: 'records' }\n }\n }\n ```\n ```js\n {\n \"post\": {\n \"id\": \"1\"\n \"title\": \"Rails is omakase\",\n \"body\": \"I want this for my ORM, I want that for my template language...\"\n \"comments\": [\"1\", \"2\"]\n }\n }\n ```\n To embed the relationship as a collection of objects with `id` and `type` keys, set\n `ids-and-types` for the related object.\n This is particularly useful for polymorphic relationships where records don't share\n the same table and the `id` is not enough information.\n For example having a user that has many pets:\n ```js\n User = Model.extend({\n name: attr('string'),\n pets: hasMany('pet', { polymorphic: true })\n });\n Pet = Model.extend({\n name: attr('string'),\n });\n Cat = Pet.extend({\n // ...\n });\n Parrot = Pet.extend({\n // ...\n });\n ```\n ```app/serializers/user.js\n import RESTSerializer, { EmbeddedRecordsMixin } from '@ember-data/serializer/rest';\n export default class UserSerializer extends RESTSerializer.extend(EmbeddedRecordsMixin) {\n attrs = {\n pets: { serialize: 'ids-and-types', deserialize: 'records' }\n }\n }\n ```\n ```js\n {\n \"user\": {\n \"id\": \"1\"\n \"name\": \"Bertin Osborne\",\n \"pets\": [\n { \"id\": \"1\", \"type\": \"Cat\" },\n { \"id\": \"1\", \"type\": \"Parrot\"}\n ]\n }\n }\n ```\n @method serializeHasMany\n @public\n @param {Snapshot} snapshot\n @param {Object} json\n @param {Object} relationship\n */\n serializeHasMany(snapshot, json, relationship) {\n let attr = relationship.key;\n if (this.noSerializeOptionSpecified(attr)) {\n this._super(snapshot, json, relationship);\n return;\n }\n if (this.hasSerializeIdsOption(attr)) {\n let serializedKey = this._getMappedKey(relationship.key, snapshot.type);\n if (serializedKey === relationship.key && this.keyForRelationship) {\n serializedKey = this.keyForRelationship(relationship.key, relationship.kind, 'serialize');\n }\n json[serializedKey] = snapshot.hasMany(attr, {\n ids: true\n });\n } else if (this.hasSerializeRecordsOption(attr)) {\n this._serializeEmbeddedHasMany(snapshot, json, relationship);\n } else {\n if (this.hasSerializeIdsAndTypesOption(attr)) {\n this._serializeHasManyAsIdsAndTypes(snapshot, json, relationship);\n }\n }\n },\n /*\n Serializes a hasMany relationship as an array of objects containing only `id` and `type`\n keys.\n This has its use case on polymorphic hasMany relationships where the server is not storing\n all records in the same table using STI, and therefore the `id` is not enough information\n TODO: Make the default in Ember-data 3.0??\n */\n _serializeHasManyAsIdsAndTypes(snapshot, json, relationship) {\n let serializedKey = this.keyForAttribute(relationship.key, 'serialize');\n let hasMany = snapshot.hasMany(relationship.key);\n json[serializedKey] = array.A(hasMany).map(function (recordSnapshot) {\n //\n // I'm sure I'm being utterly naive here. Probably id is a configurable property and\n // type too, and the modelName has to be normalized somehow.\n //\n return {\n id: recordSnapshot.id,\n type: recordSnapshot.modelName\n };\n });\n },\n _serializeEmbeddedHasMany(snapshot, json, relationship) {\n let serializedKey = this._getMappedKey(relationship.key, snapshot.type);\n if (serializedKey === relationship.key && this.keyForRelationship) {\n serializedKey = this.keyForRelationship(relationship.key, relationship.kind, 'serialize');\n }\n (debug.warn(`The embedded relationship '${serializedKey}' is undefined for '${snapshot.modelName}' with id '${snapshot.id}'. Please include it in your original payload.`, utils.typeOf(snapshot.hasMany(relationship.key)) !== 'undefined', {\n id: 'ds.serializer.embedded-relationship-undefined'\n }));\n json[serializedKey] = this._generateSerializedHasMany(snapshot, relationship);\n },\n /*\n Returns an array of embedded records serialized to JSON\n */\n _generateSerializedHasMany(snapshot, relationship) {\n let hasMany = snapshot.hasMany(relationship.key);\n let manyArray = array.A(hasMany);\n let ret = new Array(manyArray.length);\n for (let i = 0; i < manyArray.length; i++) {\n let embeddedSnapshot = manyArray[i];\n let embeddedJson = embeddedSnapshot.serialize({\n includeId: true\n });\n this.removeEmbeddedForeignKey(snapshot, embeddedSnapshot, relationship, embeddedJson);\n ret[i] = embeddedJson;\n }\n return ret;\n },\n /**\n When serializing an embedded record, modify the property (in the `JSON` payload)\n that refers to the parent record (foreign key for the relationship).\n Serializing a `belongsTo` relationship removes the property that refers to the\n parent record\n Serializing a `hasMany` relationship does not remove the property that refers to\n the parent record.\n @method removeEmbeddedForeignKey\n @public\n @param {Snapshot} snapshot\n @param {Snapshot} embeddedSnapshot\n @param {Object} relationship\n @param {Object} json\n */\n removeEmbeddedForeignKey(snapshot, embeddedSnapshot, relationship, json) {\n if (relationship.kind === 'belongsTo') {\n let parentRecord = snapshot.type.inverseFor(relationship.key, this.store);\n if (parentRecord) {\n let name = parentRecord.name;\n let embeddedSerializer = this.store.serializerFor(embeddedSnapshot.modelName);\n let parentKey = embeddedSerializer.keyForRelationship(name, parentRecord.kind, 'deserialize');\n if (parentKey) {\n delete json[parentKey];\n }\n }\n } /*else if (relationship.kind === 'hasMany') {\n return;\n }*/\n },\n // checks config for attrs option to embedded (always) - serialize and deserialize\n hasEmbeddedAlwaysOption(attr) {\n let option = this.attrsOption(attr);\n return option && option.embedded === 'always';\n },\n // checks config for attrs option to serialize ids\n hasSerializeRecordsOption(attr) {\n let alwaysEmbed = this.hasEmbeddedAlwaysOption(attr);\n let option = this.attrsOption(attr);\n return alwaysEmbed || option && option.serialize === 'records';\n },\n // checks config for attrs option to serialize records\n hasSerializeIdsOption(attr) {\n let option = this.attrsOption(attr);\n return option && (option.serialize === 'ids' || option.serialize === 'id');\n },\n // checks config for attrs option to serialize records as objects containing id and types\n hasSerializeIdsAndTypesOption(attr) {\n let option = this.attrsOption(attr);\n return option && (option.serialize === 'ids-and-types' || option.serialize === 'id-and-type');\n },\n // checks config for attrs option to serialize records\n noSerializeOptionSpecified(attr) {\n let option = this.attrsOption(attr);\n return !(option && (option.serialize || option.embedded));\n },\n // checks config for attrs option to deserialize records\n // a defined option object for a resource is treated the same as\n // `deserialize: 'records'`\n hasDeserializeRecordsOption(attr) {\n let alwaysEmbed = this.hasEmbeddedAlwaysOption(attr);\n let option = this.attrsOption(attr);\n return alwaysEmbed || option && option.deserialize === 'records';\n },\n attrsOption(attr) {\n let attrs = this.get('attrs');\n return attrs && (attrs[string.camelize(attr)] || attrs[attr]);\n },\n /**\n @method _extractEmbeddedRecords\n @private\n */\n _extractEmbeddedRecords(serializer, store, typeClass, partial) {\n typeClass.eachRelationship((key, relationship) => {\n if (serializer.hasDeserializeRecordsOption(key)) {\n if (relationship.kind === 'hasMany') {\n this._extractEmbeddedHasMany(store, key, partial, relationship);\n }\n if (relationship.kind === 'belongsTo') {\n this._extractEmbeddedBelongsTo(store, key, partial, relationship);\n }\n }\n });\n return partial;\n },\n /**\n @method _extractEmbeddedHasMany\n @private\n */\n _extractEmbeddedHasMany(store, key, hash, relationshipMeta) {\n let relationshipHash = EmberObject.get(hash, `data.relationships.${key}.data`);\n if (!relationshipHash) {\n return;\n }\n let hasMany = new Array(relationshipHash.length);\n for (let i = 0; i < relationshipHash.length; i++) {\n let item = relationshipHash[i];\n let {\n data,\n included\n } = this._normalizeEmbeddedRelationship(store, relationshipMeta, item);\n hash.included = hash.included || [];\n hash.included.push(data);\n if (included) {\n hash.included = hash.included.concat(included);\n }\n hasMany[i] = {\n id: data.id,\n type: data.type\n };\n }\n let relationship = {\n data: hasMany\n };\n EmberObject.set(hash, `data.relationships.${key}`, relationship);\n },\n /**\n @method _extractEmbeddedBelongsTo\n @private\n */\n _extractEmbeddedBelongsTo(store, key, hash, relationshipMeta) {\n let relationshipHash = EmberObject.get(hash, `data.relationships.${key}.data`);\n if (!relationshipHash) {\n return;\n }\n let {\n data,\n included\n } = this._normalizeEmbeddedRelationship(store, relationshipMeta, relationshipHash);\n hash.included = hash.included || [];\n hash.included.push(data);\n if (included) {\n hash.included = hash.included.concat(included);\n }\n let belongsTo = {\n id: data.id,\n type: data.type\n };\n let relationship = {\n data: belongsTo\n };\n EmberObject.set(hash, `data.relationships.${key}`, relationship);\n },\n /**\n @method _normalizeEmbeddedRelationship\n @private\n */\n _normalizeEmbeddedRelationship(store, relationshipMeta, relationshipHash) {\n let modelName = relationshipMeta.type;\n if (relationshipMeta.options.polymorphic) {\n modelName = relationshipHash.type;\n }\n let modelClass = store.modelFor(modelName);\n let serializer = store.serializerFor(modelName);\n return serializer.normalize(modelClass, relationshipHash, null);\n },\n isEmbeddedRecordsMixin: true\n });\n\n /*\n Check if the passed model has a `type` attribute or a relationship named `type`.\n */\n function modelHasAttributeOrRelationshipNamedType(modelClass) {\n return EmberObject.get(modelClass, 'attributes').has('type') || EmberObject.get(modelClass, 'relationshipsByName').has('type');\n }\n\n /**\n @module @ember-data/serializer\n */\n\n /**\n The `Transform` class is used to serialize and deserialize model\n attributes when they are saved or loaded from an\n adapter. Subclassing `Transform` is useful for creating custom\n attributes. All subclasses of `Transform` must implement a\n `serialize` and a `deserialize` method.\n\n Example\n\n ```app/transforms/temperature.js\n import Transform from '@ember-data/serializer/transform';\n\n // Converts centigrade in the JSON to fahrenheit in the app\n export default class TemperatureTransform extends Transform {\n deserialize(serialized, options) {\n return (serialized * 1.8) + 32;\n }\n\n serialize(deserialized, options) {\n return (deserialized - 32) / 1.8;\n }\n }\n ```\n\n Usage\n\n ```app/models/requirement.js\n import Model, { attr } from '@ember-data/model';\n\n export default class RequirementModel extends Model {\n @attr('string') name;\n @attr('temperature') temperature;\n }\n ```\n\n The options passed into the `attr` function when the attribute is\n declared on the model is also available in the transform.\n\n ```app/models/post.js\n import Model, { attr } from '@ember-data/model';\n\n export default class PostModel extends Model {\n @attr('string') title;\n @attr('markdown', {\n markdown: {\n gfm: false,\n sanitize: true\n }\n })\n markdown;\n }\n ```\n\n ```app/transforms/markdown.js\n import Transform from '@ember-data/serializer/transform';\n\n export default class MarkdownTransform extends Transform {\n serialize(deserialized, options) {\n return deserialized.raw;\n }\n\n deserialize(serialized, options) {\n let markdownOptions = options.markdown || {};\n\n return marked(serialized, markdownOptions);\n }\n }\n ```\n\n @class Transform\n @public\n */\n class Transform extends EmberObject__default[\"default\"] {\n /**\n When given a deserialized value from a record attribute this\n method must return the serialized value.\n Example\n ```javascript\n import { isEmpty } from '@ember/utils';\n serialize(deserialized, options) {\n return isEmpty(deserialized) ? null : Number(deserialized);\n }\n ```\n @method serialize\n @public\n @param deserialized The deserialized value\n @param options hash of options passed to `attr`\n @return The serialized value\n */\n /**\n When given a serialized value from a JSON object this method must\n return the deserialized value for the record attribute.\n Example\n ```javascript\n deserialize(serialized, options) {\n return empty(serialized) ? null : Number(serialized);\n }\n ```\n @method deserialize\n @public\n @param serialized The serialized value\n @param options hash of options passed to `attr`\n @return The deserialized value\n */\n }\n\n /**\n @module @ember-data/serializer\n */\n\n /**\n The `BooleanTransform` class is used to serialize and deserialize\n boolean attributes on Ember Data record objects. This transform is\n used when `boolean` is passed as the type parameter to the\n [attr](/ember-data/release/functions/@ember-data%2Fmodel/attr) function.\n\n Usage\n\n ```app/models/user.js\n import Model, { attr } from '@ember-data/model';\n\n export default class UserModel extends Model {\n @attr('boolean') isAdmin;\n @attr('string') name;\n @attr('string') email;\n }\n ```\n\n By default, the boolean transform only allows for values of `true` or\n `false`. You can opt into allowing `null` values for\n boolean attributes via `attr('boolean', { allowNull: true })`\n\n ```app/models/user.js\n import Model, { attr } from '@ember-data/model';\n\n export default class UserModel extends Model {\n @attr('string') email;\n @attr('string') username;\n @attr('boolean', { allowNull: true }) wantsWeeklyEmail;\n }\n ```\n\n @class BooleanTransform\n @public\n @extends Transform\n */\n class BooleanTransform extends Transform {\n deserialize(serialized, options) {\n if (utils.isNone(serialized) && options.allowNull === true) {\n return null;\n }\n let type = typeof serialized;\n if (type === 'boolean') {\n return serialized;\n } else if (type === 'string') {\n return /^(true|t|1)$/i.test(serialized);\n } else if (type === 'number') {\n return serialized === 1;\n } else {\n return false;\n }\n }\n serialize(deserialized, options) {\n if (utils.isNone(deserialized) && options.allowNull === true) {\n return null;\n }\n return Boolean(deserialized);\n }\n }\n\n /**\n @module @ember-data/serializer\n */\n\n /**\n The `DateTransform` class is used to serialize and deserialize\n date attributes on Ember Data record objects. This transform is used\n when `date` is passed as the type parameter to the\n [attr](/ember-data/release/functions/@ember-data%2Fmodel/attr) function. It uses the [`ISO 8601`](https://en.wikipedia.org/wiki/ISO_8601)\n standard.\n\n ```app/models/score.js\n import Model, { attr, belongsTo } from '@ember-data/model';\n\n export default class ScoreModel extends Model {\n @attr('number') value;\n @belongsTo('player') player;\n @attr('date') date;\n }\n ```\n\n @class DateTransform\n @public\n @extends Transform\n */\n\n class DateTransform extends Transform {\n deserialize(serialized) {\n let type = typeof serialized;\n if (type === 'string') {\n let offset = serialized.indexOf('+');\n if (offset !== -1 && serialized.length - 5 === offset) {\n offset += 3;\n return new Date(serialized.slice(0, offset) + ':' + serialized.slice(offset));\n }\n return new Date(serialized);\n } else if (type === 'number') {\n return new Date(serialized);\n } else if (serialized === null || serialized === undefined) {\n // if the value is null return null\n // if the value is not present in the data return undefined\n return serialized;\n } else {\n return null;\n }\n }\n serialize(date) {\n if (date instanceof Date && !isNaN(date)) {\n return date.toISOString();\n } else {\n return null;\n }\n }\n }\n\n /**\n @module @ember-data/serializer\n */\n\n function isNumber(value) {\n return value === value && value !== Infinity && value !== -Infinity;\n }\n\n /**\n The `NumberTransform` class is used to serialize and deserialize\n numeric attributes on Ember Data record objects. This transform is\n used when `number` is passed as the type parameter to the\n [attr](/ember-data/release/functions/@ember-data%2Fmodel/attr) function.\n\n Usage\n\n ```app/models/score.js\n import Model, { attr, belongsTo } from '@ember-data/model';\n\n export default class ScoreModel extends Model {\n @attr('number') value;\n @belongsTo('player') player;\n @attr('date') date;\n }\n ```\n\n @class NumberTransform\n @public\n @extends Transform\n */\n class NumberTransform extends Transform {\n deserialize(serialized) {\n let transformed;\n if (serialized === '' || serialized === null || serialized === undefined) {\n return null;\n } else {\n transformed = Number(serialized);\n return isNumber(transformed) ? transformed : null;\n }\n }\n serialize(deserialized) {\n let transformed;\n if (deserialized === '' || deserialized === null || deserialized === undefined) {\n return null;\n } else {\n transformed = Number(deserialized);\n return isNumber(transformed) ? transformed : null;\n }\n }\n }\n\n /**\n @module @ember-data/serializer\n */\n\n /**\n The `StringTransform` class is used to serialize and deserialize\n string attributes on Ember Data record objects. This transform is\n used when `string` is passed as the type parameter to the\n [attr](/ember-data/release/functions/@ember-data%2Fmodel/attr) function.\n\n Usage\n\n ```app/models/user.js\n import Model, { attr, belongsTo } from '@ember-data/model';\n\n export default class UserModel extends Model {\n @attr('boolean') isAdmin;\n @attr('string') name;\n @attr('string') email;\n }\n ```\n\n @class StringTransform\n @public\n @extends Transform\n */\n class StringTransform extends Transform {\n deserialize(serialized) {\n return utils.isNone(serialized) ? null : String(serialized);\n }\n serialize(deserialized) {\n return utils.isNone(deserialized) ? null : String(deserialized);\n }\n }\n\n exports.BooleanTransform = BooleanTransform;\n exports.DateTransform = DateTransform;\n exports.EmbeddedRecordsMixin = embeddedRecordsMixin;\n exports.NumberTransform = NumberTransform;\n exports.StringTransform = StringTransform;\n exports.Transform = Transform;\n exports.modelHasAttributeOrRelationshipNamedType = modelHasAttributeOrRelationshipNamedType;\n\n Object.defineProperty(exports, '__esModule', { value: true });\n\n}));\n","define(\"@ember-data/serializer/index\", [\"exports\", \"@ember/object\"], function (_exports, _object) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.default = void 0;\n 0; //eaimeta@70e063a35619d71f0,\"@ember/object\"eaimeta@70e063a35619d71f\n /**\n ## Overview\n \n In order to properly manage and present your data, EmberData\n needs to understand the structure of data it receives.\n \n `Serializers` convert data between the server's API format and\n the format EmberData understands.\n \n Data received from an API response is **normalized** into\n [JSON:API](https://jsonapi.org/) (the format used internally\n by EmberData), while data sent to an API is **serialized**\n into the format the API expects.\n \n ### Implementing a Serializer\n \n There are only two required serializer methods, one for\n normalizing data from the server API format into JSON:API, and\n another for serializing records via `Snapshots` into the expected\n server API format.\n \n To implement a serializer, export a class that conforms to the structure\n described by the [MinimumSerializerInterface](/ember-data/release/classes/MinimumSerializerInterface)\n from the `app/serializers/` directory. An example is below.\n \n ```ts\n import EmberObject from '@ember/object';\n \n export default class ApplicationSerializer extends EmberObject {\n normalizeResponse(store, schema, rawPayload) {\n return rawPayload;\n }\n \n serialize(snapshot, options) {\n const serializedResource = {\n id: snapshot.id,\n type: snapshot.modelName,\n attributes: snapshot.attributes()\n };\n \n return serializedResource;\n }\n }\n ```\n \n \n ### Serializer Resolution\n \n `store.serializerFor(name)` will lookup serializers defined in\n `app/serializers/` and return an instance. If no serializer is found, an\n error will be thrown.\n \n `serializerFor` first attempts to find a serializer with an exact match on `name`,\n then falls back to checking for the presence of a serializer named `application`.\n \n ```ts\n store.serializerFor('author');\n \n // lookup paths (in order) =>\n // app/serializers/author.js\n // app/serializers/application.js\n ```\n \n Most requests in EmberData are made with respect to a particular `type` (or `modelName`)\n (e.g., \"get me the full collection of **books**\" or \"get me the **employee** whose id is 37\"). We\n refer to this as the **primary** resource `type`.\n \n Typically `serializerFor` will be used to find a serializer with a name matching that of the primary\n resource `type` for the request, falling back to the `application` serializer for those types that\n do not have a defined serializer. This is often described as a `per-model` or `per-type` strategy\n for defining serializers. However, because APIs rarely format payloads per-type but rather\n per-API-version, this may not be a desired strategy.\n \n It is recommended that applications define only a single `application` adapter and serializer\n where possible.\n \n If you have multiple API formats and the per-type strategy is not viable, one strategy is to\n write an `application` adapter and serializer that make use of `options` to specify the desired\n format when making a request.\n \n ### Using a Serializer\n \n Any serializer in `app/serializers/` can be looked up by `name` using `store.serializerFor(name)`.\n \n ### Default Serializers\n \n For applications whose APIs are *very close to* or *exactly* the **REST** format or **JSON:API**\n format the `@ember-data/serializer` package contains implementations these applications can\n extend. It also contains a simple `JSONSerializer` for serializing to/from very basic JSON objects.\n \n Many applications will find writing their own serializer to be more performant and less\n complex than extending these classes even when their API format is very close to that expected\n by these serializers.\n \n It is recommended that apps write their own serializer to best suit the needs of their API and\n application.\n \n @module @ember-data/serializer\n @main @ember-data/serializer\n */\n /**\n `Serializer` is an abstract base class that you should override in your\n application to customize it for your backend. The minimum set of methods\n that you should implement is:\n \n * `normalizeResponse()`\n * `serialize()`\n \n And you can optionally override the following methods:\n \n * `normalize()`\n \n For an example implementation, see\n [JSONSerializer](JSONSerializer), the included JSON serializer.\n \n @class Serializer\n @public\n @extends Ember.EmberObject\n */\n var _default = _exports.default = _object.default.extend({\n /**\n The `store` property is the application's `store` that contains\n all records. It can be used to look up serializers for other model\n types that may be nested inside the payload response.\n Example:\n ```js\n Serializer.extend({\n extractRelationship(relationshipModelName, relationshipHash) {\n let modelClass = this.store.modelFor(relationshipModelName);\n let relationshipSerializer = this.store.serializerFor(relationshipModelName);\n return relationshipSerializer.normalize(modelClass, relationshipHash);\n }\n });\n ```\n @property store\n @type {Store}\n @public\n */\n\n /**\n The `normalizeResponse` method is used to normalize a payload from the\n server to a JSON-API Document.\n http://jsonapi.org/format/#document-structure\n Example:\n ```js\n Serializer.extend({\n normalizeResponse(store, primaryModelClass, payload, id, requestType) {\n if (requestType === 'findRecord') {\n return this.normalize(primaryModelClass, payload);\n } else {\n return payload.reduce(function(documentHash, item) {\n let { data, included } = this.normalize(primaryModelClass, item);\n documentHash.included.push(...included);\n documentHash.data.push(data);\n return documentHash;\n }, { data: [], included: [] })\n }\n }\n });\n ```\n @since 1.13.0\n @method normalizeResponse\n @public\n @param {Store} store\n @param {Model} primaryModelClass\n @param {Object} payload\n @param {String|Number} id\n @param {String} requestType\n @return {Object} JSON-API Document\n */\n normalizeResponse: null,\n /**\n The `serialize` method is used when a record is saved in order to convert\n the record into the form that your external data source expects.\n `serialize` takes an optional `options` hash with a single option:\n - `includeId`: If this is `true`, `serialize` should include the ID\n in the serialized object it builds.\n Example:\n ```js\n Serializer.extend({\n serialize(snapshot, options) {\n let json = {\n id: snapshot.id\n };\n snapshot.eachAttribute((key, attribute) => {\n json[key] = snapshot.attr(key);\n });\n snapshot.eachRelationship((key, relationship) => {\n if (relationship.kind === 'belongsTo') {\n json[key] = snapshot.belongsTo(key, { id: true });\n } else if (relationship.kind === 'hasMany') {\n json[key] = snapshot.hasMany(key, { ids: true });\n }\n });\n return json;\n },\n });\n ```\n @method serialize\n @public\n @param {Snapshot} snapshot\n @param {Object} [options]\n @return {Object}\n */\n serialize: null,\n /**\n The `normalize` method is used to convert a payload received from your\n external data source into the normalized form `store.push()` expects. You\n should override this method, munge the hash and return the normalized\n payload.\n Example:\n ```js\n Serializer.extend({\n normalize(modelClass, resourceHash) {\n let data = {\n id: resourceHash.id,\n type: modelClass.modelName,\n attributes: resourceHash\n };\n return { data: data };\n }\n })\n ```\n @method normalize\n @public\n @param {Model} typeClass\n @param {Object} hash\n @return {Object}\n */\n normalize(typeClass, hash) {\n return hash;\n }\n });\n});","define(\"@ember-data/serializer/json-api\", [\"exports\", \"@ember/debug\", \"@ember/string\", \"@ember/utils\", \"ember-inflector\", \"@ember-data/serializer/json\", \"@ember-data/store\"], function (_exports, _debug, _string, _utils, _emberInflector, _json, _store) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.default = void 0;\n 0; //eaimeta@70e063a35619d71f0,\"@ember/debug\",0,\"@ember/string\",0,\"@ember/utils\",0,\"@glimmer/env\",0,\"ember-inflector\",0,\"@ember-data/serializer/json\",0,\"@ember-data/store\"eaimeta@70e063a35619d71f\n /**\n * @module @ember-data/serializer/json-api\n */\n /**\n Ember Data 2.0 Serializer:\n \n In Ember Data a Serializer is used to serialize and deserialize\n records when they are transferred in and out of an external source.\n This process involves normalizing property names, transforming\n attribute values and serializing relationships.\n \n `JSONAPISerializer` supports the http://jsonapi.org/ spec and is the\n serializer recommended by Ember Data.\n \n This serializer normalizes a JSON API payload that looks like:\n \n ```app/models/player.js\n import Model, { attr, belongsTo } from '@ember-data/model';\n \n export default class Player extends Model {\n @attr('string') name;\n @attr('string') skill;\n @attr('number') gamesPlayed;\n @belongsTo('club') club;\n }\n ```\n \n ```app/models/club.js\n import Model, { attr, hasMany } from '@ember-data/model';\n \n export default class Club extends Model {\n @attr('string') name;\n @attr('string') location;\n @hasMany('player') players;\n }\n ```\n \n ```js\n {\n \"data\": [\n {\n \"attributes\": {\n \"name\": \"Benfica\",\n \"location\": \"Portugal\"\n },\n \"id\": \"1\",\n \"relationships\": {\n \"players\": {\n \"data\": [\n {\n \"id\": \"3\",\n \"type\": \"players\"\n }\n ]\n }\n },\n \"type\": \"clubs\"\n }\n ],\n \"included\": [\n {\n \"attributes\": {\n \"name\": \"Eusebio Silva Ferreira\",\n \"skill\": \"Rocket shot\",\n \"games-played\": 431\n },\n \"id\": \"3\",\n \"relationships\": {\n \"club\": {\n \"data\": {\n \"id\": \"1\",\n \"type\": \"clubs\"\n }\n }\n },\n \"type\": \"players\"\n }\n ]\n }\n ```\n \n to the format that the Ember Data store expects.\n \n ### Customizing meta\n \n Since a JSON API Document can have meta defined in multiple locations you can\n use the specific serializer hooks if you need to customize the meta.\n \n One scenario would be to camelCase the meta keys of your payload. The example\n below shows how this could be done using `normalizeArrayResponse` and\n `extractRelationship`.\n \n ```app/serializers/application.js\n import JSONAPISerializer from '@ember-data/serializer/json-api';\n \n export default class ApplicationSerializer extends JSONAPISerializer {\n normalizeArrayResponse(store, primaryModelClass, payload, id, requestType) {\n let normalizedDocument = super.normalizeArrayResponse(...arguments);\n \n // Customize document meta\n normalizedDocument.meta = camelCaseKeys(normalizedDocument.meta);\n \n return normalizedDocument;\n }\n \n extractRelationship(relationshipHash) {\n let normalizedRelationship = super.extractRelationship(...arguments);\n \n // Customize relationship meta\n normalizedRelationship.meta = camelCaseKeys(normalizedRelationship.meta);\n \n return normalizedRelationship;\n }\n }\n ```\n \n @main @ember-data/serializer/json-api\n @since 1.13.0\n @class JSONAPISerializer\n @public\n @extends JSONSerializer\n */\n const JSONAPISerializer = _json.default.extend({\n /**\n @method _normalizeDocumentHelper\n @param {Object} documentHash\n @return {Object}\n @private\n */\n _normalizeDocumentHelper(documentHash) {\n if ((0, _utils.typeOf)(documentHash.data) === 'object') {\n documentHash.data = this._normalizeResourceHelper(documentHash.data);\n } else if (Array.isArray(documentHash.data)) {\n let ret = new Array(documentHash.data.length);\n for (let i = 0; i < documentHash.data.length; i++) {\n let data = documentHash.data[i];\n ret[i] = this._normalizeResourceHelper(data);\n }\n documentHash.data = ret;\n }\n if (Array.isArray(documentHash.included)) {\n let ret = new Array();\n for (let i = 0; i < documentHash.included.length; i++) {\n let included = documentHash.included[i];\n let normalized = this._normalizeResourceHelper(included);\n if (normalized !== null) {\n // can be null when unknown type is encountered\n ret.push(normalized);\n }\n }\n documentHash.included = ret;\n }\n return documentHash;\n },\n /**\n @method _normalizeRelationshipDataHelper\n @param {Object} relationshipDataHash\n @return {Object}\n @private\n */\n _normalizeRelationshipDataHelper(relationshipDataHash) {\n relationshipDataHash.type = this.modelNameFromPayloadKey(relationshipDataHash.type);\n return relationshipDataHash;\n },\n /**\n @method _normalizeResourceHelper\n @param {Object} resourceHash\n @return {Object}\n @private\n */\n _normalizeResourceHelper(resourceHash) {\n (true && !(!(0, _utils.isNone)(resourceHash.type)) && (0, _debug.assert)(this.warnMessageForUndefinedType(), !(0, _utils.isNone)(resourceHash.type), {\n id: 'ds.serializer.type-is-undefined'\n }));\n let modelName, usedLookup;\n modelName = this.modelNameFromPayloadKey(resourceHash.type);\n usedLookup = 'modelNameFromPayloadKey';\n if (!this.store._hasModelFor(modelName)) {\n (true && (0, _debug.warn)(this.warnMessageNoModelForType(modelName, resourceHash.type, usedLookup), false, {\n id: 'ds.serializer.model-for-type-missing'\n }));\n return null;\n }\n let modelClass = this.store.modelFor(modelName);\n let serializer = this.store.serializerFor(modelName);\n let {\n data\n } = serializer.normalize(modelClass, resourceHash);\n return data;\n },\n /**\n Normalize some data and push it into the store.\n @method pushPayload\n @public\n @param {Store} store\n @param {Object} payload\n */\n pushPayload(store, payload) {\n let normalizedPayload = this._normalizeDocumentHelper(payload);\n store.push(normalizedPayload);\n },\n /**\n @method _normalizeResponse\n @param {Store} store\n @param {Model} primaryModelClass\n @param {Object} payload\n @param {String|Number} id\n @param {String} requestType\n @param {Boolean} isSingle\n @return {Object} JSON-API Document\n @private\n */\n _normalizeResponse(store, primaryModelClass, payload, id, requestType, isSingle) {\n let normalizedPayload = this._normalizeDocumentHelper(payload);\n return normalizedPayload;\n },\n normalizeQueryRecordResponse() {\n let normalized = this._super(...arguments);\n (true && !(!Array.isArray(normalized.data)) && (0, _debug.assert)('Expected the primary data returned by the serializer for a `queryRecord` response to be a single object but instead it was an array.', !Array.isArray(normalized.data), {\n id: 'ds.serializer.json-api.queryRecord-array-response'\n }));\n return normalized;\n },\n extractAttributes(modelClass, resourceHash) {\n let attributes = {};\n if (resourceHash.attributes) {\n modelClass.eachAttribute(key => {\n let attributeKey = this.keyForAttribute(key, 'deserialize');\n if (resourceHash.attributes[attributeKey] !== undefined) {\n attributes[key] = resourceHash.attributes[attributeKey];\n }\n if (true /* DEBUG */) {\n if (resourceHash.attributes[attributeKey] === undefined && resourceHash.attributes[key] !== undefined) {\n (true && !(false) && (0, _debug.assert)(`Your payload for '${modelClass.modelName}' contains '${key}', but your serializer is setup to look for '${attributeKey}'. This is most likely because Ember Data's JSON API serializer dasherizes attribute keys by default. You should subclass JSONAPISerializer and implement 'keyForAttribute(key) { return key; }' to prevent Ember Data from customizing your attribute keys.`, false));\n }\n }\n });\n }\n return attributes;\n },\n /**\n Returns a relationship formatted as a JSON-API \"relationship object\".\n http://jsonapi.org/format/#document-resource-object-relationships\n @method extractRelationship\n @public\n @param {Object} relationshipHash\n @return {Object}\n */\n extractRelationship(relationshipHash) {\n if ((0, _utils.typeOf)(relationshipHash.data) === 'object') {\n relationshipHash.data = this._normalizeRelationshipDataHelper(relationshipHash.data);\n }\n if (Array.isArray(relationshipHash.data)) {\n let ret = new Array(relationshipHash.data.length);\n for (let i = 0; i < relationshipHash.data.length; i++) {\n let data = relationshipHash.data[i];\n ret[i] = this._normalizeRelationshipDataHelper(data);\n }\n relationshipHash.data = ret;\n }\n return relationshipHash;\n },\n /**\n Returns the resource's relationships formatted as a JSON-API \"relationships object\".\n http://jsonapi.org/format/#document-resource-object-relationships\n @method extractRelationships\n @public\n @param {Object} modelClass\n @param {Object} resourceHash\n @return {Object}\n */\n extractRelationships(modelClass, resourceHash) {\n let relationships = {};\n if (resourceHash.relationships) {\n modelClass.eachRelationship((key, relationshipMeta) => {\n let relationshipKey = this.keyForRelationship(key, relationshipMeta.kind, 'deserialize');\n if (resourceHash.relationships[relationshipKey] !== undefined) {\n let relationshipHash = resourceHash.relationships[relationshipKey];\n relationships[key] = this.extractRelationship(relationshipHash);\n }\n if (true /* DEBUG */) {\n if (resourceHash.relationships[relationshipKey] === undefined && resourceHash.relationships[key] !== undefined) {\n (true && !(false) && (0, _debug.assert)(`Your payload for '${modelClass.modelName}' contains '${key}', but your serializer is setup to look for '${relationshipKey}'. This is most likely because Ember Data's JSON API serializer dasherizes relationship keys by default. You should subclass JSONAPISerializer and implement 'keyForRelationship(key) { return key; }' to prevent Ember Data from customizing your relationship keys.`, false));\n }\n }\n });\n }\n return relationships;\n },\n /**\n @method _extractType\n @param {Model} modelClass\n @param {Object} resourceHash\n @return {String}\n @private\n */\n _extractType(modelClass, resourceHash) {\n return this.modelNameFromPayloadKey(resourceHash.type);\n },\n /**\n Dasherizes and singularizes the model name in the payload to match\n the format Ember Data uses internally for the model name.\n For example the key `posts` would be converted to `post` and the\n key `studentAssesments` would be converted to `student-assesment`.\n @method modelNameFromPayloadKey\n @public\n @param {String} key\n @return {String} the model's modelName\n */\n modelNameFromPayloadKey(key) {\n return (0, _emberInflector.singularize)((0, _store.normalizeModelName)(key));\n },\n /**\n Converts the model name to a pluralized version of the model name.\n For example `post` would be converted to `posts` and\n `student-assesment` would be converted to `student-assesments`.\n @method payloadKeyFromModelName\n @public\n @param {String} modelName\n @return {String}\n */\n // TODO @deprecated Use payloadTypeFromModelName instead\n payloadKeyFromModelName(modelName) {\n return (0, _emberInflector.pluralize)(modelName);\n },\n normalize(modelClass, resourceHash) {\n if (resourceHash.attributes) {\n this.normalizeUsingDeclaredMapping(modelClass, resourceHash.attributes);\n }\n if (resourceHash.relationships) {\n this.normalizeUsingDeclaredMapping(modelClass, resourceHash.relationships);\n }\n let data = {\n id: this.extractId(modelClass, resourceHash),\n type: this._extractType(modelClass, resourceHash),\n attributes: this.extractAttributes(modelClass, resourceHash),\n relationships: this.extractRelationships(modelClass, resourceHash)\n };\n this.applyTransforms(modelClass, data.attributes);\n return {\n data\n };\n },\n /**\n `keyForAttribute` can be used to define rules for how to convert an\n attribute name in your model to a key in your JSON.\n By default `JSONAPISerializer` follows the format used on the examples of\n http://jsonapi.org/format and uses dashes as the word separator in the JSON\n attribute keys.\n This behaviour can be easily customized by extending this method.\n Example\n ```app/serializers/application.js\n import JSONAPISerializer from '@ember-data/serializer/json-api';\n import { dasherize } from '@ember/string';\n export default class ApplicationSerializer extends JSONAPISerializer {\n keyForAttribute(attr, method) {\n return dasherize(attr).toUpperCase();\n }\n }\n ```\n @method keyForAttribute\n @public\n @param {String} key\n @param {String} method\n @return {String} normalized key\n */\n keyForAttribute(key, method) {\n return (0, _string.dasherize)(key);\n },\n /**\n `keyForRelationship` can be used to define a custom key when\n serializing and deserializing relationship properties.\n By default `JSONAPISerializer` follows the format used on the examples of\n http://jsonapi.org/format and uses dashes as word separators in\n relationship properties.\n This behaviour can be easily customized by extending this method.\n Example\n ```app/serializers/post.js\n import JSONAPISerializer from '@ember-data/serializer/json-api';\n import { underscore } from '@ember/string';\n export default class ApplicationSerializer extends JSONAPISerializer {\n keyForRelationship(key, relationship, method) {\n return underscore(key);\n }\n }\n ```\n @method keyForRelationship\n @public\n @param {String} key\n @param {String} typeClass\n @param {String} method\n @return {String} normalized key\n */\n keyForRelationship(key, typeClass, method) {\n return (0, _string.dasherize)(key);\n },\n /**\n Called when a record is saved in order to convert the\n record into JSON.\n For example, consider this model:\n ```app/models/comment.js\n import Model, { attr, belongsTo } from '@ember-data/model';\n export default class CommentModel extends Model {\n @attr title;\n @attr body;\n @belongsTo('user', { async: false, inverse: null })\n author;\n }\n ```\n The default serialization would create a JSON-API resource object like:\n ```javascript\n {\n \"data\": {\n \"type\": \"comments\",\n \"attributes\": {\n \"title\": \"Rails is unagi\",\n \"body\": \"Rails? Omakase? O_O\",\n },\n \"relationships\": {\n \"author\": {\n \"data\": {\n \"id\": \"12\",\n \"type\": \"users\"\n }\n }\n }\n }\n }\n ```\n By default, attributes are passed through as-is, unless\n you specified an attribute type (`attr('date')`). If\n you specify a transform, the JavaScript value will be\n serialized when inserted into the attributes hash.\n Belongs-to relationships are converted into JSON-API\n resource identifier objects.\n ## IDs\n `serialize` takes an options hash with a single option:\n `includeId`. If this option is `true`, `serialize` will,\n by default include the ID in the JSON object it builds.\n The JSONAPIAdapter passes in `includeId: true` when serializing a record\n for `createRecord` or `updateRecord`.\n ## Customization\n Your server may expect data in a different format than the\n built-in serialization format.\n In that case, you can implement `serialize` yourself and\n return data formatted to match your API's expectations, or override\n the invoked adapter method and do the serialization in the adapter directly\n by using the provided snapshot.\n \n If your API's format differs greatly from the JSON:API spec, you should\n consider authoring your own adapter and serializer instead of extending\n this class.\n ```app/serializers/post.js\n import JSONAPISerializer from '@ember-data/serializer/json-api';\n export default class PostSerializer extends JSONAPISerializer {\n serialize(snapshot, options) {\n let json = {\n POST_TTL: snapshot.attr('title'),\n POST_BDY: snapshot.attr('body'),\n POST_CMS: snapshot.hasMany('comments', { ids: true })\n };\n if (options.includeId) {\n json.POST_ID_ = snapshot.id;\n }\n return json;\n }\n }\n ```\n ## Customizing an App-Wide Serializer\n If you want to define a serializer for your entire\n application, you'll probably want to use `eachAttribute`\n and `eachRelationship` on the record.\n ```app/serializers/application.js\n import JSONAPISerializer from '@ember-data/serializer/json-api';\n import { singularize } from 'ember-inflector';\n import { underscore } from '@ember/string';\n export default class ApplicationSerializer extends JSONAPISerializer {\n serialize(snapshot, options) {\n let json = {};\n snapshot.eachAttribute((name) => {\n json[serverAttributeName(name)] = snapshot.attr(name);\n });\n snapshot.eachRelationship((name, relationship) => {\n if (relationship.kind === 'hasMany') {\n json[serverHasManyName(name)] = snapshot.hasMany(name, { ids: true });\n }\n });\n if (options.includeId) {\n json.ID_ = snapshot.id;\n }\n return json;\n }\n }\n function serverAttributeName(attribute) {\n return underscore(attribute).toUpperCase();\n }\n function serverHasManyName(name) {\n return serverAttributeName(singularize(name)) + '_IDS';\n }\n ```\n This serializer will generate JSON that looks like this:\n ```javascript\n {\n \"TITLE\": \"Rails is omakase\",\n \"BODY\": \"Yep. Omakase.\",\n \"COMMENT_IDS\": [ \"1\", \"2\", \"3\" ]\n }\n ```\n ## Tweaking the Default Formatting\n If you just want to do some small tweaks on the default JSON:API formatted response,\n you can call `super.serialize` first and make the tweaks\n on the returned object.\n ```app/serializers/post.js\n import JSONAPISerializer from '@ember-data/serializer/json-api';\n export default class PostSerializer extends JSONAPISerializer {\n serialize(snapshot, options) {\n let json = super.serialize(...arguments);\n json.data.attributes.subject = json.data.attributes.title;\n delete json.data.attributes.title;\n return json;\n }\n }\n ```\n @method serialize\n @public\n @param {Snapshot} snapshot\n @param {Object} options\n @return {Object} json\n */\n serialize(snapshot, options) {\n let data = this._super(...arguments);\n data.type = this.payloadKeyFromModelName(snapshot.modelName);\n return {\n data\n };\n },\n serializeAttribute(snapshot, json, key, attribute) {\n let type = attribute.type;\n if (this._canSerialize(key)) {\n json.attributes = json.attributes || {};\n let value = snapshot.attr(key);\n if (type) {\n let transform = this.transformFor(type);\n value = transform.serialize(value, attribute.options);\n }\n let payloadKey = this._getMappedKey(key, snapshot.type);\n if (payloadKey === key) {\n payloadKey = this.keyForAttribute(key, 'serialize');\n }\n json.attributes[payloadKey] = value;\n }\n },\n serializeBelongsTo(snapshot, json, relationship) {\n let key = relationship.key;\n if (this._canSerialize(key)) {\n let belongsTo = snapshot.belongsTo(key);\n let belongsToIsNotNew = belongsTo && !belongsTo.isNew;\n if (belongsTo === null || belongsToIsNotNew) {\n json.relationships = json.relationships || {};\n let payloadKey = this._getMappedKey(key, snapshot.type);\n if (payloadKey === key) {\n payloadKey = this.keyForRelationship(key, 'belongsTo', 'serialize');\n }\n let data = null;\n if (belongsTo) {\n let payloadType = this.payloadKeyFromModelName(belongsTo.modelName);\n data = {\n type: payloadType,\n id: belongsTo.id\n };\n }\n json.relationships[payloadKey] = {\n data\n };\n }\n }\n },\n serializeHasMany(snapshot, json, relationship) {\n let key = relationship.key;\n if (this.shouldSerializeHasMany(snapshot, key, relationship)) {\n let hasMany = snapshot.hasMany(key);\n if (hasMany !== undefined) {\n json.relationships = json.relationships || {};\n let payloadKey = this._getMappedKey(key, snapshot.type);\n if (payloadKey === key && this.keyForRelationship) {\n payloadKey = this.keyForRelationship(key, 'hasMany', 'serialize');\n }\n\n // only serialize has many relationships that are not new\n let nonNewHasMany = hasMany.filter(item => item.record && !item.record.get('isNew'));\n let data = new Array(nonNewHasMany.length);\n for (let i = 0; i < nonNewHasMany.length; i++) {\n let item = hasMany[i];\n let payloadType = this.payloadKeyFromModelName(item.modelName);\n data[i] = {\n type: payloadType,\n id: item.id\n };\n }\n json.relationships[payloadKey] = {\n data\n };\n }\n }\n }\n });\n if (true /* DEBUG */) {\n JSONAPISerializer.reopen({\n init(...args) {\n this._super(...args);\n (true && !(!this.isEmbeddedRecordsMixin || this.isEmbeddedRecordsMixinCompatible === true) && (0, _debug.assert)(`You've used the EmbeddedRecordsMixin in ${this.toString()} which is not fully compatible with the JSON:API specification. Please confirm that this works for your specific API and add \\`this.isEmbeddedRecordsMixinCompatible = true\\` to your serializer.`, !this.isEmbeddedRecordsMixin || this.isEmbeddedRecordsMixinCompatible === true, {\n id: 'ds.serializer.embedded-records-mixin-not-supported'\n }));\n let constructor = this.constructor;\n (true && (0, _debug.warn)(`You've defined 'extractMeta' in ${constructor.toString()} which is not used for serializers extending JSONAPISerializer. Read more at https://api.emberjs.com/ember-data/release/classes/JSONAPISerializer on how to customize meta when using JSON API.`, this.extractMeta === _json.default.prototype.extractMeta, {\n id: 'ds.serializer.json-api.extractMeta'\n }));\n },\n warnMessageForUndefinedType() {\n return 'Encountered a resource object with an undefined type (resolved resource using ' + this.constructor.toString() + ')';\n },\n warnMessageNoModelForType(modelName, originalType, usedLookup) {\n return `Encountered a resource object with type \"${originalType}\", but no model was found for model name \"${modelName}\" (resolved model name using '${this.constructor.toString()}.${usedLookup}(\"${originalType}\")').`;\n }\n });\n }\n var _default = _exports.default = JSONAPISerializer;\n});","define(\"@ember-data/serializer/json\", [\"exports\", \"@ember/application\", \"@ember/debug\", \"@ember/object\", \"@ember/utils\", \"@ember-data/serializer\", \"@ember-data/store\", \"@ember-data/store/-private\", \"@ember-data/serializer/-private\"], function (_exports, _application, _debug, _object, _utils, _serializer, _store, _private, _private2) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.default = void 0;\n 0; //eaimeta@70e063a35619d71f0,\"@ember/application\",0,\"@ember/debug\",0,\"@ember/object\",0,\"@ember/utils\",0,\"@ember-data/serializer\",0,\"@ember-data/store\",0,\"@ember-data/store/-private\",0,\"@ember-data/serializer/-private\"eaimeta@70e063a35619d71f\n /**\n * @module @ember-data/serializer/json\n */\n /**\n Ember Data 2.0 Serializer:\n \n In Ember Data a Serializer is used to serialize and deserialize\n records when they are transferred in and out of an external source.\n This process involves normalizing property names, transforming\n attribute values and serializing relationships.\n \n By default, Ember Data uses and recommends the `JSONAPISerializer`.\n \n `JSONSerializer` is useful for simpler or legacy backends that may\n not support the http://jsonapi.org/ spec.\n \n For example, given the following `User` model and JSON payload:\n \n ```app/models/user.js\n import Model, { attr, belongsTo, hasMany } from '@ember-data/model';\n \n export default class UserModel extends Model {\n @hasMany('user') friends;\n @belongsTo('location') house;\n \n @attr('string') name;\n }\n ```\n \n ```js\n {\n id: 1,\n name: 'Sebastian',\n friends: [3, 4],\n links: {\n house: '/houses/lefkada'\n }\n }\n ```\n \n `JSONSerializer` will normalize the JSON payload to the JSON API format that the\n Ember Data store expects.\n \n You can customize how JSONSerializer processes its payload by passing options in\n the `attrs` hash or by subclassing the `JSONSerializer` and overriding hooks:\n \n - To customize how a single record is normalized, use the `normalize` hook.\n - To customize how `JSONSerializer` normalizes the whole server response, use the\n `normalizeResponse` hook.\n - To customize how `JSONSerializer` normalizes a specific response from the server,\n use one of the many specific `normalizeResponse` hooks.\n - To customize how `JSONSerializer` normalizes your id, attributes or relationships,\n use the `extractId`, `extractAttributes` and `extractRelationships` hooks.\n \n The `JSONSerializer` normalization process follows these steps:\n \n 1. `normalizeResponse`\n - entry method to the serializer.\n 2. `normalizeCreateRecordResponse`\n - a `normalizeResponse` for a specific operation is called.\n 3. `normalizeSingleResponse`|`normalizeArrayResponse`\n - for methods like `createRecord` we expect a single record back, while for methods like `findAll` we expect multiple records back.\n 4. `normalize`\n - `normalizeArrayResponse` iterates and calls `normalize` for each of its records while `normalizeSingle`\n calls it once. This is the method you most likely want to subclass.\n 5. `extractId` | `extractAttributes` | `extractRelationships`\n - `normalize` delegates to these methods to\n turn the record payload into the JSON API format.\n \n @main @ember-data/serializer/json\n @class JSONSerializer\n @public\n @extends Serializer\n */\n const JSONSerializer = _serializer.default.extend({\n /**\n The `primaryKey` is used when serializing and deserializing\n data. Ember Data always uses the `id` property to store the id of\n the record. The external source may not always follow this\n convention. In these cases it is useful to override the\n `primaryKey` property to match the `primaryKey` of your external\n store.\n Example\n ```app/serializers/application.js\n import JSONSerializer from '@ember-data/serializer/json';\n export default class ApplicationSerializer extends JSONSerializer {\n primaryKey = '_id'\n }\n ```\n @property primaryKey\n @type {String}\n @public\n @default 'id'\n */\n primaryKey: 'id',\n /**\n The `attrs` object can be used to declare a simple mapping between\n property names on `Model` records and payload keys in the\n serialized JSON object representing the record. An object with the\n property `key` can also be used to designate the attribute's key on\n the response payload.\n Example\n ```app/models/person.js\n import Model, { attr } from '@ember-data/model';\n export default class PersonModel extends Model {\n @attr('string') firstName;\n @attr('string') lastName;\n @attr('string') occupation;\n @attr('boolean') admin;\n }\n ```\n ```app/serializers/person.js\n import JSONSerializer from '@ember-data/serializer/json';\n export default class PersonSerializer extends JSONSerializer {\n attrs = {\n admin: 'is_admin',\n occupation: { key: 'career' }\n }\n }\n ```\n You can also remove attributes and relationships by setting the `serialize`\n key to `false` in your mapping object.\n Example\n ```app/serializers/person.js\n import JSONSerializer from '@ember-data/serializer/json';\n export default class PostSerializer extends JSONSerializer {\n attrs = {\n admin: { serialize: false },\n occupation: { key: 'career' }\n }\n }\n ```\n When serialized:\n ```javascript\n {\n \"firstName\": \"Harry\",\n \"lastName\": \"Houdini\",\n \"career\": \"magician\"\n }\n ```\n Note that the `admin` is now not included in the payload.\n Setting `serialize` to `true` enforces serialization for hasMany\n relationships even if it's neither a many-to-many nor many-to-none\n relationship.\n @property attrs\n @public\n @type {Object}\n */\n mergedProperties: ['attrs'],\n /**\n Given a subclass of `Model` and a JSON object this method will\n iterate through each attribute of the `Model` and invoke the\n `Transform#deserialize` method on the matching property of the\n JSON object. This method is typically called after the\n serializer's `normalize` method.\n @method applyTransforms\n @private\n @param {Model} typeClass\n @param {Object} data The data to transform\n @return {Object} data The transformed data object\n */\n applyTransforms(typeClass, data) {\n let attributes = (0, _object.get)(typeClass, 'attributes');\n typeClass.eachTransformedAttribute((key, typeClass) => {\n if (data[key] === undefined) {\n return;\n }\n let transform = this.transformFor(typeClass);\n let transformMeta = attributes.get(key);\n data[key] = transform.deserialize(data[key], transformMeta.options);\n });\n return data;\n },\n /**\n The `normalizeResponse` method is used to normalize a payload from the\n server to a JSON-API Document.\n http://jsonapi.org/format/#document-structure\n This method delegates to a more specific normalize method based on\n the `requestType`.\n To override this method with a custom one, make sure to call\n `return super.normalizeResponse(store, primaryModelClass, payload, id, requestType)` with your\n pre-processed data.\n Here's an example of using `normalizeResponse` manually:\n ```javascript\n socket.on('message', function(message) {\n let data = message.data;\n let modelClass = store.modelFor(data.modelName);\n let serializer = store.serializerFor(data.modelName);\n let normalized = serializer.normalizeSingleResponse(store, modelClass, data, data.id);\n store.push(normalized);\n });\n ```\n @since 1.13.0\n @method normalizeResponse\n @public\n @param {Store} store\n @param {Model} primaryModelClass\n @param {Object} payload\n @param {String|Number} id\n @param {String} requestType\n @return {Object} JSON-API Document\n */\n normalizeResponse(store, primaryModelClass, payload, id, requestType) {\n switch (requestType) {\n case 'findRecord':\n return this.normalizeFindRecordResponse(...arguments);\n case 'queryRecord':\n return this.normalizeQueryRecordResponse(...arguments);\n case 'findAll':\n return this.normalizeFindAllResponse(...arguments);\n case 'findBelongsTo':\n return this.normalizeFindBelongsToResponse(...arguments);\n case 'findHasMany':\n return this.normalizeFindHasManyResponse(...arguments);\n case 'findMany':\n return this.normalizeFindManyResponse(...arguments);\n case 'query':\n return this.normalizeQueryResponse(...arguments);\n case 'createRecord':\n return this.normalizeCreateRecordResponse(...arguments);\n case 'deleteRecord':\n return this.normalizeDeleteRecordResponse(...arguments);\n case 'updateRecord':\n return this.normalizeUpdateRecordResponse(...arguments);\n }\n },\n /**\n Called by the default normalizeResponse implementation when the\n type of request is `findRecord`\n @since 1.13.0\n @method normalizeFindRecordResponse\n @public\n @param {Store} store\n @param {Model} primaryModelClass\n @param {Object} payload\n @param {String|Number} id\n @param {String} requestType\n @return {Object} JSON-API Document\n */\n normalizeFindRecordResponse(store, primaryModelClass, payload, id, requestType) {\n return this.normalizeSingleResponse(...arguments);\n },\n /**\n Called by the default normalizeResponse implementation when the\n type of request is `queryRecord`\n @since 1.13.0\n @method normalizeQueryRecordResponse\n @public\n @param {Store} store\n @param {Model} primaryModelClass\n @param {Object} payload\n @param {String|Number} id\n @param {String} requestType\n @return {Object} JSON-API Document\n */\n normalizeQueryRecordResponse(store, primaryModelClass, payload, id, requestType) {\n return this.normalizeSingleResponse(...arguments);\n },\n /**\n Called by the default normalizeResponse implementation when the\n type of request is `findAll`\n @since 1.13.0\n @method normalizeFindAllResponse\n @public\n @param {Store} store\n @param {Model} primaryModelClass\n @param {Object} payload\n @param {String|Number} id\n @param {String} requestType\n @return {Object} JSON-API Document\n */\n normalizeFindAllResponse(store, primaryModelClass, payload, id, requestType) {\n return this.normalizeArrayResponse(...arguments);\n },\n /**\n Called by the default normalizeResponse implementation when the\n type of request is `findBelongsTo`\n @since 1.13.0\n @method normalizeFindBelongsToResponse\n @public\n @param {Store} store\n @param {Model} primaryModelClass\n @param {Object} payload\n @param {String|Number} id\n @param {String} requestType\n @return {Object} JSON-API Document\n */\n normalizeFindBelongsToResponse(store, primaryModelClass, payload, id, requestType) {\n return this.normalizeSingleResponse(...arguments);\n },\n /**\n Called by the default normalizeResponse implementation when the\n type of request is `findHasMany`\n @since 1.13.0\n @method normalizeFindHasManyResponse\n @public\n @param {Store} store\n @param {Model} primaryModelClass\n @param {Object} payload\n @param {String|Number} id\n @param {String} requestType\n @return {Object} JSON-API Document\n */\n normalizeFindHasManyResponse(store, primaryModelClass, payload, id, requestType) {\n return this.normalizeArrayResponse(...arguments);\n },\n /**\n Called by the default normalizeResponse implementation when the\n type of request is `findMany`\n @since 1.13.0\n @method normalizeFindManyResponse\n @public\n @param {Store} store\n @param {Model} primaryModelClass\n @param {Object} payload\n @param {String|Number} id\n @param {String} requestType\n @return {Object} JSON-API Document\n */\n normalizeFindManyResponse(store, primaryModelClass, payload, id, requestType) {\n return this.normalizeArrayResponse(...arguments);\n },\n /**\n Called by the default normalizeResponse implementation when the\n type of request is `query`\n @since 1.13.0\n @method normalizeQueryResponse\n @public\n @param {Store} store\n @param {Model} primaryModelClass\n @param {Object} payload\n @param {String|Number} id\n @param {String} requestType\n @return {Object} JSON-API Document\n */\n normalizeQueryResponse(store, primaryModelClass, payload, id, requestType) {\n return this.normalizeArrayResponse(...arguments);\n },\n /**\n Called by the default normalizeResponse implementation when the\n type of request is `createRecord`\n @since 1.13.0\n @method normalizeCreateRecordResponse\n @public\n @param {Store} store\n @param {Model} primaryModelClass\n @param {Object} payload\n @param {String|Number} id\n @param {String} requestType\n @return {Object} JSON-API Document\n */\n normalizeCreateRecordResponse(store, primaryModelClass, payload, id, requestType) {\n return this.normalizeSaveResponse(...arguments);\n },\n /**\n Called by the default normalizeResponse implementation when the\n type of request is `deleteRecord`\n @since 1.13.0\n @method normalizeDeleteRecordResponse\n @public\n @param {Store} store\n @param {Model} primaryModelClass\n @param {Object} payload\n @param {String|Number} id\n @param {String} requestType\n @return {Object} JSON-API Document\n */\n normalizeDeleteRecordResponse(store, primaryModelClass, payload, id, requestType) {\n return this.normalizeSaveResponse(...arguments);\n },\n /**\n Called by the default normalizeResponse implementation when the\n type of request is `updateRecord`\n @since 1.13.0\n @method normalizeUpdateRecordResponse\n @public\n @param {Store} store\n @param {Model} primaryModelClass\n @param {Object} payload\n @param {String|Number} id\n @param {String} requestType\n @return {Object} JSON-API Document\n */\n normalizeUpdateRecordResponse(store, primaryModelClass, payload, id, requestType) {\n return this.normalizeSaveResponse(...arguments);\n },\n /**\n normalizeUpdateRecordResponse, normalizeCreateRecordResponse and\n normalizeDeleteRecordResponse delegate to this method by default.\n @since 1.13.0\n @method normalizeSaveResponse\n @public\n @param {Store} store\n @param {Model} primaryModelClass\n @param {Object} payload\n @param {String|Number} id\n @param {String} requestType\n @return {Object} JSON-API Document\n */\n normalizeSaveResponse(store, primaryModelClass, payload, id, requestType) {\n return this.normalizeSingleResponse(...arguments);\n },\n /**\n normalizeQueryResponse and normalizeFindRecordResponse delegate to this\n method by default.\n @since 1.13.0\n @method normalizeSingleResponse\n @public\n @param {Store} store\n @param {Model} primaryModelClass\n @param {Object} payload\n @param {String|Number} id\n @param {String} requestType\n @return {Object} JSON-API Document\n */\n normalizeSingleResponse(store, primaryModelClass, payload, id, requestType) {\n return this._normalizeResponse(store, primaryModelClass, payload, id, requestType, true);\n },\n /**\n normalizeQueryResponse, normalizeFindManyResponse, and normalizeFindHasManyResponse delegate\n to this method by default.\n @since 1.13.0\n @method normalizeArrayResponse\n @public\n @param {Store} store\n @param {Model} primaryModelClass\n @param {Object} payload\n @param {String|Number} id\n @param {String} requestType\n @return {Object} JSON-API Document\n */\n normalizeArrayResponse(store, primaryModelClass, payload, id, requestType) {\n return this._normalizeResponse(store, primaryModelClass, payload, id, requestType, false);\n },\n /**\n @method _normalizeResponse\n @param {Store} store\n @param {Model} primaryModelClass\n @param {Object} payload\n @param {String|Number} id\n @param {String} requestType\n @param {Boolean} isSingle\n @return {Object} JSON-API Document\n @private\n */\n _normalizeResponse(store, primaryModelClass, payload, id, requestType, isSingle) {\n let documentHash = {\n data: null,\n included: []\n };\n let meta = this.extractMeta(store, primaryModelClass, payload);\n if (meta) {\n (true && !((0, _utils.typeOf)(meta) === 'object') && (0, _debug.assert)('The `meta` returned from `extractMeta` has to be an object, not \"' + (0, _utils.typeOf)(meta) + '\".', (0, _utils.typeOf)(meta) === 'object'));\n documentHash.meta = meta;\n }\n if (isSingle) {\n let {\n data,\n included\n } = this.normalize(primaryModelClass, payload);\n documentHash.data = data;\n if (included) {\n documentHash.included = included;\n }\n } else {\n let ret = new Array(payload.length);\n for (let i = 0, l = payload.length; i < l; i++) {\n let item = payload[i];\n let {\n data,\n included\n } = this.normalize(primaryModelClass, item);\n if (included) {\n documentHash.included = documentHash.included.concat(included);\n }\n ret[i] = data;\n }\n documentHash.data = ret;\n }\n return documentHash;\n },\n /**\n Normalizes a part of the JSON payload returned by\n the server. You should override this method, munge the hash\n and call super if you have generic normalization to do.\n It takes the type of the record that is being normalized\n (as a Model class), the property where the hash was\n originally found, and the hash to normalize.\n You can use this method, for example, to normalize underscored keys to camelized\n or other general-purpose normalizations.\n Example\n ```app/serializers/application.js\n import JSONSerializer from '@ember-data/serializer/json';\n import { underscore } from '@ember/string';\n import { get } from '@ember/object';\n export default class ApplicationSerializer extends JSONSerializer {\n normalize(typeClass, hash) {\n let fields = get(typeClass, 'fields');\n fields.forEach(function(type, field) {\n let payloadField = underscore(field);\n if (field === payloadField) { return; }\n hash[field] = hash[payloadField];\n delete hash[payloadField];\n });\n return super.normalize(...arguments);\n }\n }\n ```\n @method normalize\n @public\n @param {Model} typeClass\n @param {Object} hash\n @return {Object}\n */\n normalize(modelClass, resourceHash) {\n let data = null;\n if (resourceHash) {\n this.normalizeUsingDeclaredMapping(modelClass, resourceHash);\n if ((0, _utils.typeOf)(resourceHash.links) === 'object') {\n this.normalizeUsingDeclaredMapping(modelClass, resourceHash.links);\n }\n data = {\n id: this.extractId(modelClass, resourceHash),\n type: modelClass.modelName,\n attributes: this.extractAttributes(modelClass, resourceHash),\n relationships: this.extractRelationships(modelClass, resourceHash)\n };\n this.applyTransforms(modelClass, data.attributes);\n }\n return {\n data\n };\n },\n /**\n Returns the resource's ID.\n @method extractId\n @public\n @param {Object} modelClass\n @param {Object} resourceHash\n @return {String}\n */\n extractId(modelClass, resourceHash) {\n let primaryKey = (0, _object.get)(this, 'primaryKey');\n let id = resourceHash[primaryKey];\n return (0, _private.coerceId)(id);\n },\n /**\n Returns the resource's attributes formatted as a JSON-API \"attributes object\".\n http://jsonapi.org/format/#document-resource-object-attributes\n @method extractAttributes\n @public\n @param {Object} modelClass\n @param {Object} resourceHash\n @return {Object}\n */\n extractAttributes(modelClass, resourceHash) {\n let attributeKey;\n let attributes = {};\n modelClass.eachAttribute(key => {\n attributeKey = this.keyForAttribute(key, 'deserialize');\n if (resourceHash[attributeKey] !== undefined) {\n attributes[key] = resourceHash[attributeKey];\n }\n });\n return attributes;\n },\n /**\n Returns a relationship formatted as a JSON-API \"relationship object\".\n http://jsonapi.org/format/#document-resource-object-relationships\n @method extractRelationship\n @public\n @param {Object} relationshipModelName\n @param {Object} relationshipHash\n @return {Object}\n */\n extractRelationship(relationshipModelName, relationshipHash) {\n if ((0, _utils.isNone)(relationshipHash)) {\n return null;\n }\n /*\n When `relationshipHash` is an object it usually means that the relationship\n is polymorphic. It could however also be embedded resources that the\n EmbeddedRecordsMixin has be able to process.\n */\n if ((0, _utils.typeOf)(relationshipHash) === 'object') {\n if (relationshipHash.id) {\n relationshipHash.id = (0, _private.coerceId)(relationshipHash.id);\n }\n let modelClass = this.store.modelFor(relationshipModelName);\n if (relationshipHash.type && !(0, _private2.modelHasAttributeOrRelationshipNamedType)(modelClass)) {\n relationshipHash.type = this.modelNameFromPayloadKey(relationshipHash.type);\n }\n return relationshipHash;\n }\n return {\n id: (0, _private.coerceId)(relationshipHash),\n type: relationshipModelName\n };\n },\n /**\n Returns a polymorphic relationship formatted as a JSON-API \"relationship object\".\n http://jsonapi.org/format/#document-resource-object-relationships\n `relationshipOptions` is a hash which contains more information about the\n polymorphic relationship which should be extracted:\n - `resourceHash` complete hash of the resource the relationship should be\n extracted from\n - `relationshipKey` key under which the value for the relationship is\n extracted from the resourceHash\n - `relationshipMeta` meta information about the relationship\n @method extractPolymorphicRelationship\n @public\n @param {Object} relationshipModelName\n @param {Object} relationshipHash\n @param {Object} relationshipOptions\n @return {Object}\n */\n extractPolymorphicRelationship(relationshipModelName, relationshipHash, relationshipOptions) {\n return this.extractRelationship(relationshipModelName, relationshipHash);\n },\n /**\n Returns the resource's relationships formatted as a JSON-API \"relationships object\".\n http://jsonapi.org/format/#document-resource-object-relationships\n @method extractRelationships\n @public\n @param {Object} modelClass\n @param {Object} resourceHash\n @return {Object}\n */\n extractRelationships(modelClass, resourceHash) {\n let relationships = {};\n modelClass.eachRelationship((key, relationshipMeta) => {\n let relationship = null;\n let relationshipKey = this.keyForRelationship(key, relationshipMeta.kind, 'deserialize');\n if (resourceHash[relationshipKey] !== undefined) {\n let data = null;\n let relationshipHash = resourceHash[relationshipKey];\n if (relationshipMeta.kind === 'belongsTo') {\n if (relationshipMeta.options.polymorphic) {\n // extracting a polymorphic belongsTo may need more information\n // than the type and the hash (which might only be an id) for the\n // relationship, hence we pass the key, resource and\n // relationshipMeta too\n data = this.extractPolymorphicRelationship(relationshipMeta.type, relationshipHash, {\n key,\n resourceHash,\n relationshipMeta\n });\n } else {\n data = this.extractRelationship(relationshipMeta.type, relationshipHash);\n }\n } else if (relationshipMeta.kind === 'hasMany') {\n if (!(0, _utils.isNone)(relationshipHash)) {\n data = new Array(relationshipHash.length);\n if (relationshipMeta.options.polymorphic) {\n for (let i = 0, l = relationshipHash.length; i < l; i++) {\n let item = relationshipHash[i];\n data[i] = this.extractPolymorphicRelationship(relationshipMeta.type, item, {\n key,\n resourceHash,\n relationshipMeta\n });\n }\n } else {\n for (let i = 0, l = relationshipHash.length; i < l; i++) {\n let item = relationshipHash[i];\n data[i] = this.extractRelationship(relationshipMeta.type, item);\n }\n }\n }\n }\n relationship = {\n data\n };\n }\n let linkKey = this.keyForLink(key, relationshipMeta.kind);\n if (resourceHash.links && resourceHash.links[linkKey] !== undefined) {\n let related = resourceHash.links[linkKey];\n relationship = relationship || {};\n relationship.links = {\n related\n };\n }\n if (relationship) {\n relationships[key] = relationship;\n }\n });\n return relationships;\n },\n /**\n Dasherizes the model name in the payload\n @method modelNameFromPayloadKey\n @public\n @param {String} key\n @return {String} the model's modelName\n */\n modelNameFromPayloadKey(key) {\n return (0, _store.normalizeModelName)(key);\n },\n /**\n @method normalizeRelationships\n @private\n */\n normalizeRelationships(typeClass, hash) {\n let payloadKey;\n if (this.keyForRelationship) {\n typeClass.eachRelationship((key, relationship) => {\n payloadKey = this.keyForRelationship(key, relationship.kind, 'deserialize');\n if (key === payloadKey) {\n return;\n }\n if (hash[payloadKey] === undefined) {\n return;\n }\n hash[key] = hash[payloadKey];\n delete hash[payloadKey];\n });\n }\n },\n /**\n @method normalizeUsingDeclaredMapping\n @private\n */\n normalizeUsingDeclaredMapping(modelClass, hash) {\n let attrs = (0, _object.get)(this, 'attrs');\n let normalizedKey;\n let payloadKey;\n if (attrs) {\n for (let key in attrs) {\n normalizedKey = payloadKey = this._getMappedKey(key, modelClass);\n if (hash[payloadKey] === undefined) {\n continue;\n }\n if ((0, _object.get)(modelClass, 'attributes').has(key)) {\n normalizedKey = this.keyForAttribute(key);\n }\n if ((0, _object.get)(modelClass, 'relationshipsByName').has(key)) {\n normalizedKey = this.keyForRelationship(key);\n }\n if (payloadKey !== normalizedKey) {\n hash[normalizedKey] = hash[payloadKey];\n delete hash[payloadKey];\n }\n }\n }\n },\n /**\n Looks up the property key that was set by the custom `attr` mapping\n passed to the serializer.\n @method _getMappedKey\n @private\n @param {String} key\n @return {String} key\n */\n _getMappedKey(key, modelClass) {\n (true && (0, _debug.warn)('There is no attribute or relationship with the name `' + key + '` on `' + modelClass.modelName + '`. Check your serializers attrs hash.', (0, _object.get)(modelClass, 'attributes').has(key) || (0, _object.get)(modelClass, 'relationshipsByName').has(key), {\n id: 'ds.serializer.no-mapped-attrs-key'\n }));\n let attrs = (0, _object.get)(this, 'attrs');\n let mappedKey;\n if (attrs && attrs[key]) {\n mappedKey = attrs[key];\n //We need to account for both the { title: 'post_title' } and\n //{ title: { key: 'post_title' }} forms\n if (mappedKey.key) {\n mappedKey = mappedKey.key;\n }\n if (typeof mappedKey === 'string') {\n key = mappedKey;\n }\n }\n return key;\n },\n /**\n Check attrs.key.serialize property to inform if the `key`\n can be serialized\n @method _canSerialize\n @private\n @param {String} key\n @return {boolean} true if the key can be serialized\n */\n _canSerialize(key) {\n let attrs = (0, _object.get)(this, 'attrs');\n return !attrs || !attrs[key] || attrs[key].serialize !== false;\n },\n /**\n When attrs.key.serialize is set to true then\n it takes priority over the other checks and the related\n attribute/relationship will be serialized\n @method _mustSerialize\n @private\n @param {String} key\n @return {boolean} true if the key must be serialized\n */\n _mustSerialize(key) {\n let attrs = (0, _object.get)(this, 'attrs');\n return attrs && attrs[key] && attrs[key].serialize === true;\n },\n /**\n Check if the given hasMany relationship should be serialized\n By default only many-to-many and many-to-none relationships are serialized.\n This could be configured per relationship by Serializer's `attrs` object.\n @method shouldSerializeHasMany\n @public\n @param {Snapshot} snapshot\n @param {String} key\n @param {String} relationshipType\n @return {boolean} true if the hasMany relationship should be serialized\n */\n shouldSerializeHasMany(snapshot, key, relationship) {\n let relationshipType = snapshot.type.determineRelationshipType(relationship, this.store);\n if (this._mustSerialize(key)) {\n return true;\n }\n return this._canSerialize(key) && (relationshipType === 'manyToNone' || relationshipType === 'manyToMany');\n },\n // SERIALIZE\n /**\n Called when a record is saved in order to convert the\n record into JSON.\n By default, it creates a JSON object with a key for\n each attribute and belongsTo relationship.\n For example, consider this model:\n ```app/models/comment.js\n import Model, { attr, belongsTo } from '@ember-data/model';\n export default class CommentModel extends Model {\n @attr title;\n @attr body;\n @belongsTo('user') author;\n }\n ```\n The default serialization would create a JSON object like:\n ```javascript\n {\n \"title\": \"Rails is unagi\",\n \"body\": \"Rails? Omakase? O_O\",\n \"author\": 12\n }\n ```\n By default, attributes are passed through as-is, unless\n you specified an attribute type (`attr('date')`). If\n you specify a transform, the JavaScript value will be\n serialized when inserted into the JSON hash.\n By default, belongs-to relationships are converted into\n IDs when inserted into the JSON hash.\n ## IDs\n `serialize` takes an options hash with a single option:\n `includeId`. If this option is `true`, `serialize` will,\n by default include the ID in the JSON object it builds.\n The adapter passes in `includeId: true` when serializing\n a record for `createRecord`, but not for `updateRecord`.\n ## Customization\n Your server may expect a different JSON format than the\n built-in serialization format.\n In that case, you can implement `serialize` yourself and\n return a JSON hash of your choosing.\n ```app/serializers/post.js\n import JSONSerializer from '@ember-data/serializer/json';\n export default class PostSerializer extends JSONSerializer {\n serialize(snapshot, options) {\n let json = {\n POST_TTL: snapshot.attr('title'),\n POST_BDY: snapshot.attr('body'),\n POST_CMS: snapshot.hasMany('comments', { ids: true })\n };\n if (options.includeId) {\n json.POST_ID_ = snapshot.id;\n }\n return json;\n }\n }\n ```\n ## Customizing an App-Wide Serializer\n If you want to define a serializer for your entire\n application, you'll probably want to use `eachAttribute`\n and `eachRelationship` on the record.\n ```app/serializers/application.js\n import JSONSerializer from '@ember-data/serializer/json';\n import { singularize } from 'ember-inflector';\n export default class ApplicationSerializer extends JSONSerializer {\n serialize(snapshot, options) {\n let json = {};\n snapshot.eachAttribute((name) => {\n json[serverAttributeName(name)] = snapshot.attr(name);\n });\n snapshot.eachRelationship((name, relationship) => {\n if (relationship.kind === 'hasMany') {\n json[serverHasManyName(name)] = snapshot.hasMany(name, { ids: true });\n }\n });\n if (options.includeId) {\n json.ID_ = snapshot.id;\n }\n return json;\n }\n }\n function serverAttributeName(attribute) {\n return attribute.underscore().toUpperCase();\n }\n function serverHasManyName(name) {\n return serverAttributeName(singularize(name)) + \"_IDS\";\n }\n ```\n This serializer will generate JSON that looks like this:\n ```javascript\n {\n \"TITLE\": \"Rails is omakase\",\n \"BODY\": \"Yep. Omakase.\",\n \"COMMENT_IDS\": [ \"1\", \"2\", \"3\" ]\n }\n ```\n ## Tweaking the Default JSON\n If you just want to do some small tweaks on the default JSON,\n you can call `super.serialize` first and make the tweaks on\n the returned JSON.\n ```app/serializers/post.js\n import JSONSerializer from '@ember-data/serializer/json';\n export default class PostSerializer extends JSONSerializer {\n serialize(snapshot, options) {\n let json = super.serialize(...arguments);\n json.subject = json.title;\n delete json.title;\n return json;\n }\n }\n ```\n @method serialize\n @public\n @param {Snapshot} snapshot\n @param {Object} options\n @return {Object} json\n */\n serialize(snapshot, options) {\n let json = {};\n if (options && options.includeId) {\n const id = snapshot.id;\n if (id) {\n json[(0, _object.get)(this, 'primaryKey')] = id;\n }\n }\n snapshot.eachAttribute((key, attribute) => {\n this.serializeAttribute(snapshot, json, key, attribute);\n });\n snapshot.eachRelationship((key, relationship) => {\n if (relationship.kind === 'belongsTo') {\n this.serializeBelongsTo(snapshot, json, relationship);\n } else if (relationship.kind === 'hasMany') {\n this.serializeHasMany(snapshot, json, relationship);\n }\n });\n return json;\n },\n /**\n You can use this method to customize how a serialized record is added to the complete\n JSON hash to be sent to the server. By default the JSON Serializer does not namespace\n the payload and just sends the raw serialized JSON object.\n If your server expects namespaced keys, you should consider using the RESTSerializer.\n Otherwise you can override this method to customize how the record is added to the hash.\n The hash property should be modified by reference.\n For example, your server may expect underscored root objects.\n ```app/serializers/application.js\n import RESTSerializer from '@ember-data/serializer/rest';\n import { decamelize } from '@ember/string';\n export default class ApplicationSerializer extends RESTSerializer {\n serializeIntoHash(data, type, snapshot, options) {\n let root = decamelize(type.modelName);\n data[root] = this.serialize(snapshot, options);\n }\n }\n ```\n @method serializeIntoHash\n @public\n @param {Object} hash\n @param {Model} typeClass\n @param {Snapshot} snapshot\n @param {Object} options\n */\n serializeIntoHash(hash, typeClass, snapshot, options) {\n Object.assign(hash, this.serialize(snapshot, options));\n },\n /**\n `serializeAttribute` can be used to customize how `attr`\n properties are serialized\n For example if you wanted to ensure all your attributes were always\n serialized as properties on an `attributes` object you could\n write:\n ```app/serializers/application.js\n import JSONSerializer from '@ember-data/serializer/json';\n export default class ApplicationSerializer extends JSONSerializer {\n serializeAttribute(snapshot, json, key, attributes) {\n json.attributes = json.attributes || {};\n super.serializeAttribute(snapshot, json.attributes, key, attributes);\n }\n }\n ```\n @method serializeAttribute\n @public\n @param {Snapshot} snapshot\n @param {Object} json\n @param {String} key\n @param {Object} attribute\n */\n serializeAttribute(snapshot, json, key, attribute) {\n if (this._canSerialize(key)) {\n let type = attribute.type;\n let value = snapshot.attr(key);\n if (type) {\n let transform = this.transformFor(type);\n value = transform.serialize(value, attribute.options);\n }\n\n // if provided, use the mapping provided by `attrs` in\n // the serializer\n let payloadKey = this._getMappedKey(key, snapshot.type);\n if (payloadKey === key && this.keyForAttribute) {\n payloadKey = this.keyForAttribute(key, 'serialize');\n }\n json[payloadKey] = value;\n }\n },\n /**\n `serializeBelongsTo` can be used to customize how `belongsTo`\n properties are serialized.\n Example\n ```app/serializers/post.js\n import JSONSerializer from '@ember-data/serializer/json';\n import { isNone } from '@ember/utils';\n export default class PostSerializer extends JSONSerializer {\n serializeBelongsTo(snapshot, json, relationship) {\n let key = relationship.key;\n let belongsTo = snapshot.belongsTo(key);\n key = this.keyForRelationship ? this.keyForRelationship(key, \"belongsTo\", \"serialize\") : key;\n json[key] = isNone(belongsTo) ? belongsTo : belongsTo.record.toJSON();\n }\n }\n ```\n @method serializeBelongsTo\n @public\n @param {Snapshot} snapshot\n @param {Object} json\n @param {Object} relationship\n */\n serializeBelongsTo(snapshot, json, relationship) {\n let key = relationship.key;\n if (this._canSerialize(key)) {\n let belongsToId = snapshot.belongsTo(key, {\n id: true\n });\n\n // if provided, use the mapping provided by `attrs` in\n // the serializer\n let payloadKey = this._getMappedKey(key, snapshot.type);\n if (payloadKey === key && this.keyForRelationship) {\n payloadKey = this.keyForRelationship(key, 'belongsTo', 'serialize');\n }\n\n //Need to check whether the id is there for new&async records\n if ((0, _utils.isNone)(belongsToId)) {\n json[payloadKey] = null;\n } else {\n json[payloadKey] = belongsToId;\n }\n if (relationship.options.polymorphic) {\n this.serializePolymorphicType(snapshot, json, relationship);\n }\n }\n },\n /**\n `serializeHasMany` can be used to customize how `hasMany`\n properties are serialized.\n Example\n ```app/serializers/post.js\n import JSONSerializer from '@ember-data/serializer/json';\n export default class PostSerializer extends JSONSerializer {\n serializeHasMany(snapshot, json, relationship) {\n let key = relationship.key;\n if (key === 'comments') {\n return;\n } else {\n super.serializeHasMany(...arguments);\n }\n }\n }\n ```\n @method serializeHasMany\n @public\n @param {Snapshot} snapshot\n @param {Object} json\n @param {Object} relationship\n */\n serializeHasMany(snapshot, json, relationship) {\n let key = relationship.key;\n if (this.shouldSerializeHasMany(snapshot, key, relationship)) {\n let hasMany = snapshot.hasMany(key, {\n ids: true\n });\n if (hasMany !== undefined) {\n // if provided, use the mapping provided by `attrs` in\n // the serializer\n let payloadKey = this._getMappedKey(key, snapshot.type);\n if (payloadKey === key && this.keyForRelationship) {\n payloadKey = this.keyForRelationship(key, 'hasMany', 'serialize');\n }\n json[payloadKey] = hasMany;\n // TODO support for polymorphic manyToNone and manyToMany relationships\n }\n }\n },\n /**\n You can use this method to customize how polymorphic objects are\n serialized. Objects are considered to be polymorphic if\n `{ polymorphic: true }` is pass as the second argument to the\n `belongsTo` function.\n Example\n ```app/serializers/comment.js\n import JSONSerializer from '@ember-data/serializer/json';\n import { isNone } from '@ember/utils';\n export default class CommentSerializer extends JSONSerializer {\n serializePolymorphicType(snapshot, json, relationship) {\n let key = relationship.key;\n let belongsTo = snapshot.belongsTo(key);\n key = this.keyForAttribute ? this.keyForAttribute(key, 'serialize') : key;\n if (isNone(belongsTo)) {\n json[key + '_type'] = null;\n } else {\n json[key + '_type'] = belongsTo.modelName;\n }\n }\n }\n ```\n @method serializePolymorphicType\n @public\n @param {Snapshot} snapshot\n @param {Object} json\n @param {Object} relationship\n */\n serializePolymorphicType() {},\n /**\n `extractMeta` is used to deserialize any meta information in the\n adapter payload. By default Ember Data expects meta information to\n be located on the `meta` property of the payload object.\n Example\n ```app/serializers/post.js\n import JSONSerializer from '@ember-data/serializer/json';\n export default class PostSerializer extends JSONSerializer {\n extractMeta(store, typeClass, payload) {\n if (payload && payload.hasOwnProperty('_pagination')) {\n let meta = payload._pagination;\n delete payload._pagination;\n return meta;\n }\n }\n }\n ```\n @method extractMeta\n @public\n @param {Store} store\n @param {Model} modelClass\n @param {Object} payload\n */\n extractMeta(store, modelClass, payload) {\n if (payload && payload['meta'] !== undefined) {\n let meta = payload.meta;\n delete payload.meta;\n return meta;\n }\n },\n /**\n `extractErrors` is used to extract model errors when a call\n to `Model#save` fails with an `InvalidError`. By default\n Ember Data expects error information to be located on the `errors`\n property of the payload object.\n This serializer expects this `errors` object to be an Array similar\n to the following, compliant with the https://jsonapi.org/format/#errors specification:\n ```js\n {\n \"errors\": [\n {\n \"detail\": \"This username is already taken!\",\n \"source\": {\n \"pointer\": \"data/attributes/username\"\n }\n }, {\n \"detail\": \"Doesn't look like a valid email.\",\n \"source\": {\n \"pointer\": \"data/attributes/email\"\n }\n }\n ]\n }\n ```\n The key `detail` provides a textual description of the problem.\n Alternatively, the key `title` can be used for the same purpose.\n The nested keys `source.pointer` detail which specific element\n of the request data was invalid.\n Note that JSON-API also allows for object-level errors to be placed\n in an object with pointer `data`, signifying that the problem\n cannot be traced to a specific attribute:\n ```javascript\n {\n \"errors\": [\n {\n \"detail\": \"Some generic non property error message\",\n \"source\": {\n \"pointer\": \"data\"\n }\n }\n ]\n }\n ```\n When turn into a `Errors` object, you can read these errors\n through the property `base`:\n ```handlebars\n {{#each @model.errors.base as |error|}}\n
\n {{error.message}}\n
\n {{/each}}\n ```\n Example of alternative implementation, overriding the default\n behavior to deal with a different format of errors:\n ```app/serializers/post.js\n import JSONSerializer from '@ember-data/serializer/json';\n export default class PostSerializer extends JSONSerializer {\n extractErrors(store, typeClass, payload, id) {\n if (payload && typeof payload === 'object' && payload._problems) {\n payload = payload._problems;\n this.normalizeErrors(typeClass, payload);\n }\n return payload;\n }\n }\n ```\n @method extractErrors\n @public\n @param {Store} store\n @param {Model} typeClass\n @param {Object} payload\n @param {(String|Number)} id\n @return {Object} json The deserialized errors\n */\n extractErrors(store, typeClass, payload, id) {\n if (payload && typeof payload === 'object' && payload.errors) {\n payload = (0, _private.errorsArrayToHash)(payload.errors);\n this.normalizeUsingDeclaredMapping(typeClass, payload);\n typeClass.eachAttribute(name => {\n let key = this.keyForAttribute(name, 'deserialize');\n if (key !== name && payload[key] !== undefined) {\n payload[name] = payload[key];\n delete payload[key];\n }\n });\n typeClass.eachRelationship(name => {\n let key = this.keyForRelationship(name, 'deserialize');\n if (key !== name && payload[key] !== undefined) {\n payload[name] = payload[key];\n delete payload[key];\n }\n });\n }\n return payload;\n },\n /**\n `keyForAttribute` can be used to define rules for how to convert an\n attribute name in your model to a key in your JSON.\n Example\n ```app/serializers/application.js\n import JSONSerializer from '@ember-data/serializer/json';\n import { underscore } from '@ember/string';\n export default class ApplicationSerializer extends JSONSerializer {\n keyForAttribute(attr, method) {\n return underscore(attr).toUpperCase();\n }\n }\n ```\n @method keyForAttribute\n @public\n @param {String} key\n @param {String} method\n @return {String} normalized key\n */\n keyForAttribute(key, method) {\n return key;\n },\n /**\n `keyForRelationship` can be used to define a custom key when\n serializing and deserializing relationship properties. By default\n `JSONSerializer` does not provide an implementation of this method.\n Example\n ```app/serializers/post.js\n import JSONSerializer from '@ember-data/serializer/json';\n import { underscore } from '@ember/string';\n export default class PostSerializer extends JSONSerializer {\n keyForRelationship(key, relationship, method) {\n return `rel_${underscore(key)}`;\n }\n }\n ```\n @method keyForRelationship\n @public\n @param {String} key\n @param {String} typeClass\n @param {String} method\n @return {String} normalized key\n */\n keyForRelationship(key, typeClass, method) {\n return key;\n },\n /**\n `keyForLink` can be used to define a custom key when deserializing link\n properties.\n @method keyForLink\n @public\n @param {String} key\n @param {String} kind `belongsTo` or `hasMany`\n @return {String} normalized key\n */\n keyForLink(key, kind) {\n return key;\n },\n // HELPERS\n\n /**\n @method transformFor\n @private\n @param {String} attributeType\n @param {Boolean} skipAssertion\n @return {Transform} transform\n */\n transformFor(attributeType, skipAssertion) {\n let transform = (0, _application.getOwner)(this).lookup('transform:' + attributeType);\n (true && !(skipAssertion || !!transform) && (0, _debug.assert)(`Unable to find the transform for \\`attr('${attributeType}')\\``, skipAssertion || !!transform));\n return transform;\n }\n });\n var _default = _exports.default = JSONSerializer;\n});","define(\"@ember-data/serializer/rest\", [\"exports\", \"@ember/array\", \"@ember/debug\", \"@ember/string\", \"@ember/utils\", \"ember-inflector\", \"@ember-data/serializer/json\", \"@ember-data/store\", \"@ember-data/store/-private\", \"@ember-data/serializer/-private\"], function (_exports, _array, _debug, _string, _utils, _emberInflector, _json, _store, _private, _private2) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n Object.defineProperty(_exports, \"EmbeddedRecordsMixin\", {\n enumerable: true,\n get: function () {\n return _private2.EmbeddedRecordsMixin;\n }\n });\n _exports.default = void 0;\n 0; //eaimeta@70e063a35619d71f0,\"@ember/array\",0,\"@ember/debug\",0,\"@ember/string\",0,\"@ember/utils\",0,\"@glimmer/env\",0,\"ember-inflector\",0,\"@ember-data/serializer/json\",0,\"@ember-data/store\",0,\"@ember-data/store/-private\",0,\"@ember-data/serializer/-private\",0,\"@ember-data/serializer/-private\"eaimeta@70e063a35619d71f\n /**\n * @module @ember-data/serializer/rest\n */\n /**\n Normally, applications will use the `RESTSerializer` by implementing\n the `normalize` method.\n \n This allows you to do whatever kind of munging you need and is\n especially useful if your server is inconsistent and you need to\n do munging differently for many different kinds of responses.\n \n See the `normalize` documentation for more information.\n \n ## Across the Board Normalization\n \n There are also a number of hooks that you might find useful to define\n across-the-board rules for your payload. These rules will be useful\n if your server is consistent, or if you're building an adapter for\n an infrastructure service, like Firebase, and want to encode service\n conventions.\n \n For example, if all of your keys are underscored and all-caps, but\n otherwise consistent with the names you use in your models, you\n can implement across-the-board rules for how to convert an attribute\n name in your model to a key in your JSON.\n \n ```app/serializers/application.js\n import RESTSerializer from '@ember-data/serializer/rest';\n import { underscore } from '@ember/string';\n \n export default class ApplicationSerializer extends RESTSerializer {\n keyForAttribute(attr, method) {\n return underscore(attr).toUpperCase();\n }\n }\n ```\n \n You can also implement `keyForRelationship`, which takes the name\n of the relationship as the first parameter, the kind of\n relationship (`hasMany` or `belongsTo`) as the second parameter, and\n the method (`serialize` or `deserialize`) as the third parameter.\n \n @class RESTSerializer\n @main @ember-data/serializer/rest\n @public\n @extends JSONSerializer\n */\n const RESTSerializer = _json.default.extend({\n /**\n `keyForPolymorphicType` can be used to define a custom key when\n serializing and deserializing a polymorphic type. By default, the\n returned key is `${key}Type`.\n Example\n ```app/serializers/post.js\n import RESTSerializer from '@ember-data/serializer/rest';\n export default class ApplicationSerializer extends RESTSerializer {\n keyForPolymorphicType(key, relationship) {\n let relationshipKey = this.keyForRelationship(key);\n return 'type-' + relationshipKey;\n }\n }\n ```\n @method keyForPolymorphicType\n @public\n @param {String} key\n @param {String} typeClass\n @param {String} method\n @return {String} normalized key\n */\n keyForPolymorphicType(key, typeClass, method) {\n let relationshipKey = this.keyForRelationship(key);\n return `${relationshipKey}Type`;\n },\n /**\n Normalizes a part of the JSON payload returned by\n the server. You should override this method, munge the hash\n and call super if you have generic normalization to do.\n It takes the type of the record that is being normalized\n (as a Model class), the property where the hash was\n originally found, and the hash to normalize.\n For example, if you have a payload that looks like this:\n ```js\n {\n \"post\": {\n \"id\": 1,\n \"title\": \"Rails is omakase\",\n \"comments\": [ 1, 2 ]\n },\n \"comments\": [{\n \"id\": 1,\n \"body\": \"FIRST\"\n }, {\n \"id\": 2,\n \"body\": \"Rails is unagi\"\n }]\n }\n ```\n The `normalize` method will be called three times:\n * With `App.Post`, `\"posts\"` and `{ id: 1, title: \"Rails is omakase\", ... }`\n * With `App.Comment`, `\"comments\"` and `{ id: 1, body: \"FIRST\" }`\n * With `App.Comment`, `\"comments\"` and `{ id: 2, body: \"Rails is unagi\" }`\n You can use this method, for example, to normalize underscored keys to camelized\n or other general-purpose normalizations. You will only need to implement\n `normalize` and manipulate the payload as desired.\n For example, if the `IDs` under `\"comments\"` are provided as `_id` instead of\n `id`, you can specify how to normalize just the comments:\n ```app/serializers/post.js\n import RESTSerializer from '@ember-data/serializer/rest';\n export default class ApplicationSerializer extends RESTSerializer {\n normalize(model, hash, prop) {\n if (prop === 'comments') {\n hash.id = hash._id;\n delete hash._id;\n }\n return super.normalize(...arguments);\n }\n }\n ```\n On each call to the `normalize` method, the third parameter (`prop`) is always\n one of the keys that were in the original payload or in the result of another\n normalization as `normalizeResponse`.\n @method normalize\n @public\n @param {Model} modelClass\n @param {Object} resourceHash\n @param {String} prop\n @return {Object}\n */\n\n /**\n Normalizes an array of resource payloads and returns a JSON-API Document\n with primary data and, if any, included data as `{ data, included }`.\n @method _normalizeArray\n @param {Store} store\n @param {String} modelName\n @param {Object} arrayHash\n @param {String} prop\n @return {Object}\n @private\n */\n _normalizeArray(store, modelName, arrayHash, prop) {\n let documentHash = {\n data: [],\n included: []\n };\n let modelClass = store.modelFor(modelName);\n let serializer = store.serializerFor(modelName);\n (0, _array.makeArray)(arrayHash).forEach(hash => {\n let {\n data,\n included\n } = this._normalizePolymorphicRecord(store, hash, prop, modelClass, serializer);\n documentHash.data.push(data);\n if (included) {\n documentHash.included = documentHash.included.concat(included);\n }\n });\n return documentHash;\n },\n _normalizePolymorphicRecord(store, hash, prop, primaryModelClass, primarySerializer) {\n let serializer = primarySerializer;\n let modelClass = primaryModelClass;\n let primaryHasTypeAttribute = (0, _private2.modelHasAttributeOrRelationshipNamedType)(primaryModelClass);\n if (!primaryHasTypeAttribute && hash.type) {\n // Support polymorphic records in async relationships\n let modelName = this.modelNameFromPayloadKey(hash.type);\n if (store._hasModelFor(modelName)) {\n serializer = store.serializerFor(modelName);\n modelClass = store.modelFor(modelName);\n }\n }\n return serializer.normalize(modelClass, hash, prop);\n },\n /**\n @method _normalizeResponse\n @param {Store} store\n @param {Model} primaryModelClass\n @param {Object} payload\n @param {String|Number} id\n @param {String} requestType\n @param {Boolean} isSingle\n @return {Object} JSON-API Document\n @private\n */\n _normalizeResponse(store, primaryModelClass, payload, id, requestType, isSingle) {\n let documentHash = {\n data: null,\n included: []\n };\n let meta = this.extractMeta(store, primaryModelClass, payload);\n if (meta) {\n (true && !((0, _utils.typeOf)(meta) === 'object') && (0, _debug.assert)('The `meta` returned from `extractMeta` has to be an object, not \"' + (0, _utils.typeOf)(meta) + '\".', (0, _utils.typeOf)(meta) === 'object'));\n documentHash.meta = meta;\n }\n let keys = Object.keys(payload);\n for (var i = 0, length = keys.length; i < length; i++) {\n var prop = keys[i];\n var modelName = prop;\n var forcedSecondary = false;\n\n /*\n If you want to provide sideloaded records of the same type that the\n primary data you can do that by prefixing the key with `_`.\n Example\n ```\n {\n users: [\n { id: 1, title: 'Tom', manager: 3 },\n { id: 2, title: 'Yehuda', manager: 3 }\n ],\n _users: [\n { id: 3, title: 'Tomster' }\n ]\n }\n ```\n This forces `_users` to be added to `included` instead of `data`.\n */\n if (prop.charAt(0) === '_') {\n forcedSecondary = true;\n modelName = prop.substr(1);\n }\n var typeName = this.modelNameFromPayloadKey(modelName);\n if (!store._hasModelFor(typeName)) {\n (true && (0, _debug.warn)(this.warnMessageNoModelForKey(modelName, typeName), false, {\n id: 'ds.serializer.model-for-key-missing'\n }));\n continue;\n }\n var isPrimary = !forcedSecondary && this.isPrimaryType(store, typeName, primaryModelClass);\n var value = payload[prop];\n if (value === null) {\n continue;\n }\n (true && !(!(requestType === 'queryRecord' && isPrimary && Array.isArray(value))) && (0, _debug.assert)('The adapter returned an array for the primary data of a `queryRecord` response. `queryRecord` should return a single record.', !(requestType === 'queryRecord' && isPrimary && Array.isArray(value))));\n /*\n Support primary data as an object instead of an array.\n Example\n ```\n {\n user: { id: 1, title: 'Tom', manager: 3 }\n }\n ```\n */\n if (isPrimary && !Array.isArray(value)) {\n let {\n data,\n included\n } = this._normalizePolymorphicRecord(store, value, prop, primaryModelClass, this);\n documentHash.data = data;\n if (included) {\n documentHash.included = documentHash.included.concat(included);\n }\n continue;\n }\n let {\n data,\n included\n } = this._normalizeArray(store, typeName, value, prop);\n if (included) {\n documentHash.included = documentHash.included.concat(included);\n }\n if (isSingle) {\n data.forEach(resource => {\n /*\n Figures out if this is the primary record or not.\n It's either:\n 1. The record with the same ID as the original request\n 2. If it's a newly created record without an ID, the first record\n in the array\n */\n let isUpdatedRecord = isPrimary && (0, _private.coerceId)(resource.id) === id;\n let isFirstCreatedRecord = isPrimary && !id && !documentHash.data;\n if (isFirstCreatedRecord || isUpdatedRecord) {\n documentHash.data = resource;\n } else {\n documentHash.included.push(resource);\n }\n });\n } else {\n if (isPrimary) {\n documentHash.data = data;\n } else {\n if (data) {\n documentHash.included = documentHash.included.concat(data);\n }\n }\n }\n }\n return documentHash;\n },\n isPrimaryType(store, modelName, primaryModelClass) {\n return (0, _store.normalizeModelName)(modelName) === primaryModelClass.modelName;\n },\n /**\n This method allows you to push a payload containing top-level\n collections of records organized per type.\n ```js\n {\n \"posts\": [{\n \"id\": \"1\",\n \"title\": \"Rails is omakase\",\n \"author\", \"1\",\n \"comments\": [ \"1\" ]\n }],\n \"comments\": [{\n \"id\": \"1\",\n \"body\": \"FIRST\"\n }],\n \"users\": [{\n \"id\": \"1\",\n \"name\": \"@d2h\"\n }]\n }\n ```\n It will first normalize the payload, so you can use this to push\n in data streaming in from your server structured the same way\n that fetches and saves are structured.\n @method pushPayload\n @public\n @param {Store} store\n @param {Object} payload\n */\n pushPayload(store, payload) {\n let documentHash = {\n data: [],\n included: []\n };\n for (var prop in payload) {\n var modelName = this.modelNameFromPayloadKey(prop);\n if (!store._hasModelFor(modelName)) {\n (true && (0, _debug.warn)(this.warnMessageNoModelForKey(prop, modelName), false, {\n id: 'ds.serializer.model-for-key-missing'\n }));\n continue;\n }\n var type = store.modelFor(modelName);\n var typeSerializer = store.serializerFor(type.modelName);\n (0, _array.makeArray)(payload[prop]).forEach(hash => {\n let {\n data,\n included\n } = typeSerializer.normalize(type, hash, prop);\n documentHash.data.push(data);\n if (included) {\n documentHash.included = documentHash.included.concat(included);\n }\n });\n }\n store.push(documentHash);\n },\n /**\n This method is used to convert each JSON root key in the payload\n into a modelName that it can use to look up the appropriate model for\n that part of the payload.\n For example, your server may send a model name that does not correspond with\n the name of the model in your app. Let's take a look at an example model,\n and an example payload:\n ```app/models/post.js\n import Model from '@ember-data/model';\n export default class Post extends Model {}\n ```\n ```javascript\n {\n \"blog/post\": {\n \"id\": \"1\n }\n }\n ```\n Ember Data is going to normalize the payload's root key for the modelName. As a result,\n it will try to look up the \"blog/post\" model. Since we don't have a model called \"blog/post\"\n (or a file called app/models/blog/post.js in ember-cli), Ember Data will throw an error\n because it cannot find the \"blog/post\" model.\n Since we want to remove this namespace, we can define a serializer for the application that will\n remove \"blog/\" from the payload key whenver it's encountered by Ember Data:\n ```app/serializers/application.js\n import RESTSerializer from '@ember-data/serializer/rest';\n export default class ApplicationSerializer extends RESTSerializer {\n modelNameFromPayloadKey(payloadKey) {\n if (payloadKey === 'blog/post') {\n return super.modelNameFromPayloadKey(payloadKey.replace('blog/', ''));\n } else {\n return super.modelNameFromPayloadKey(payloadKey);\n }\n }\n }\n ```\n After refreshing, Ember Data will appropriately look up the \"post\" model.\n By default the modelName for a model is its\n name in dasherized form. This means that a payload key like \"blogPost\" would be\n normalized to \"blog-post\" when Ember Data looks up the model. Usually, Ember Data\n can use the correct inflection to do this for you. Most of the time, you won't\n need to override `modelNameFromPayloadKey` for this purpose.\n @method modelNameFromPayloadKey\n @public\n @param {String} key\n @return {String} the model's modelName\n */\n modelNameFromPayloadKey(key) {\n return (0, _emberInflector.singularize)((0, _store.normalizeModelName)(key));\n },\n // SERIALIZE\n\n /**\n Called when a record is saved in order to convert the\n record into JSON.\n By default, it creates a JSON object with a key for\n each attribute and belongsTo relationship.\n For example, consider this model:\n ```app/models/comment.js\n import Model, { attr, belongsTo } from '@ember-data/model';\n export default class Comment extends Model {\n @attr title\n @attr body\n @belongsTo('user') author\n }\n ```\n The default serialization would create a JSON object like:\n ```js\n {\n \"title\": \"Rails is unagi\",\n \"body\": \"Rails? Omakase? O_O\",\n \"author\": 12\n }\n ```\n By default, attributes are passed through as-is, unless\n you specified an attribute type (`attr('date')`). If\n you specify a transform, the JavaScript value will be\n serialized when inserted into the JSON hash.\n By default, belongs-to relationships are converted into\n IDs when inserted into the JSON hash.\n ## IDs\n `serialize` takes an options hash with a single option:\n `includeId`. If this option is `true`, `serialize` will,\n by default include the ID in the JSON object it builds.\n The adapter passes in `includeId: true` when serializing\n a record for `createRecord`, but not for `updateRecord`.\n ## Customization\n Your server may expect a different JSON format than the\n built-in serialization format.\n In that case, you can implement `serialize` yourself and\n return a JSON hash of your choosing.\n ```app/serializers/post.js\n import RESTSerializer from '@ember-data/serializer/rest';\n export default class ApplicationSerializer extends RESTSerializer {\n serialize(snapshot, options) {\n let json = {\n POST_TTL: snapshot.attr('title'),\n POST_BDY: snapshot.attr('body'),\n POST_CMS: snapshot.hasMany('comments', { ids: true })\n };\n if (options.includeId) {\n json.POST_ID_ = snapshot.id;\n }\n return json;\n }\n }\n ```\n ## Customizing an App-Wide Serializer\n If you want to define a serializer for your entire\n application, you'll probably want to use `eachAttribute`\n and `eachRelationship` on the record.\n ```app/serializers/application.js\n import RESTSerializer from '@ember-data/serializer/rest';\n import { pluralize } from 'ember-inflector';\n export default class ApplicationSerializer extends RESTSerializer {\n serialize(snapshot, options) {\n let json = {};\n snapshot.eachAttribute(function(name) {\n json[serverAttributeName(name)] = snapshot.attr(name);\n });\n snapshot.eachRelationship(function(name, relationship) {\n if (relationship.kind === 'hasMany') {\n json[serverHasManyName(name)] = snapshot.hasMany(name, { ids: true });\n }\n });\n if (options.includeId) {\n json.ID_ = snapshot.id;\n }\n return json;\n }\n }\n function serverAttributeName(attribute) {\n return attribute.underscore().toUpperCase();\n }\n function serverHasManyName(name) {\n return serverAttributeName(singularize(name)) + \"_IDS\";\n }\n ```\n This serializer will generate JSON that looks like this:\n ```js\n {\n \"TITLE\": \"Rails is omakase\",\n \"BODY\": \"Yep. Omakase.\",\n \"COMMENT_IDS\": [ 1, 2, 3 ]\n }\n ```\n ## Tweaking the Default JSON\n If you just want to do some small tweaks on the default JSON,\n you can call super first and make the tweaks on the returned\n JSON.\n ```app/serializers/post.js\n import RESTSerializer from '@ember-data/serializer/rest';\n export default class ApplicationSerializer extends RESTSerializer {\n serialize(snapshot, options) {\n let json = super.serialize(snapshot, options);\n json.subject = json.title;\n delete json.title;\n return json;\n }\n }\n ```\n @method serialize\n @public\n @param {Snapshot} snapshot\n @param {Object} options\n @return {Object} json\n */\n serialize(snapshot, options) {\n return this._super(...arguments);\n },\n /**\n You can use this method to customize the root keys serialized into the JSON.\n The hash property should be modified by reference (possibly using something like _.extend)\n By default the REST Serializer sends the modelName of a model, which is a camelized\n version of the name.\n For example, your server may expect underscored root objects.\n ```app/serializers/application.js\n import RESTSerializer from '@ember-data/serializer/rest';\n import { decamelize } from '@ember/string';\n export default class ApplicationSerializer extends RESTSerializer {\n serializeIntoHash(data, type, record, options) {\n let root = decamelize(type.modelName);\n data[root] = this.serialize(record, options);\n }\n }\n ```\n @method serializeIntoHash\n @public\n @param {Object} hash\n @param {Model} typeClass\n @param {Snapshot} snapshot\n @param {Object} options\n */\n serializeIntoHash(hash, typeClass, snapshot, options) {\n let normalizedRootKey = this.payloadKeyFromModelName(typeClass.modelName);\n hash[normalizedRootKey] = this.serialize(snapshot, options);\n },\n /**\n You can use `payloadKeyFromModelName` to override the root key for an outgoing\n request. By default, the RESTSerializer returns a camelized version of the\n model's name.\n For a model called TacoParty, its `modelName` would be the string `taco-party`. The RESTSerializer\n will send it to the server with `tacoParty` as the root key in the JSON payload:\n ```js\n {\n \"tacoParty\": {\n \"id\": \"1\",\n \"location\": \"Matthew Beale's House\"\n }\n }\n ```\n For example, your server may expect dasherized root objects:\n ```app/serializers/application.js\n import RESTSerializer from '@ember-data/serializer/rest';\n import { dasherize } from '@ember/string';\n export default class ApplicationSerializer extends RESTSerializer {\n payloadKeyFromModelName(modelName) {\n return dasherize(modelName);\n }\n }\n ```\n Given a `TacoParty` model, calling `save` on it would produce an outgoing\n request like:\n ```js\n {\n \"taco-party\": {\n \"id\": \"1\",\n \"location\": \"Matthew Beale's House\"\n }\n }\n ```\n @method payloadKeyFromModelName\n @public\n @param {String} modelName\n @return {String}\n */\n payloadKeyFromModelName(modelName) {\n return (0, _string.camelize)(modelName);\n },\n /**\n You can use this method to customize how polymorphic objects are serialized.\n By default the REST Serializer creates the key by appending `Type` to\n the attribute and value from the model's camelcased model name.\n @method serializePolymorphicType\n @public\n @param {Snapshot} snapshot\n @param {Object} json\n @param {Object} relationship\n */\n serializePolymorphicType(snapshot, json, relationship) {\n let key = relationship.key;\n let typeKey = this.keyForPolymorphicType(key, relationship.type, 'serialize');\n let belongsTo = snapshot.belongsTo(key);\n if ((0, _utils.isNone)(belongsTo)) {\n json[typeKey] = null;\n } else {\n json[typeKey] = (0, _string.camelize)(belongsTo.modelName);\n }\n },\n /**\n You can use this method to customize how a polymorphic relationship should\n be extracted.\n @method extractPolymorphicRelationship\n @public\n @param {Object} relationshipType\n @param {Object} relationshipHash\n @param {Object} relationshipOptions\n @return {Object}\n */\n extractPolymorphicRelationship(relationshipType, relationshipHash, relationshipOptions) {\n let {\n key,\n resourceHash,\n relationshipMeta\n } = relationshipOptions;\n\n // A polymorphic belongsTo relationship can be present in the payload\n // either in the form where the `id` and the `type` are given:\n //\n // {\n // message: { id: 1, type: 'post' }\n // }\n //\n // or by the `id` and a `Type` attribute:\n //\n // {\n // message: 1,\n // messageType: 'post'\n // }\n //\n // The next code checks if the latter case is present and returns the\n // corresponding JSON-API representation. The former case is handled within\n // the base class JSONSerializer.\n let isPolymorphic = relationshipMeta.options.polymorphic;\n let typeProperty = this.keyForPolymorphicType(key, relationshipType, 'deserialize');\n if (isPolymorphic && resourceHash[typeProperty] !== undefined && typeof relationshipHash !== 'object') {\n let type = this.modelNameFromPayloadKey(resourceHash[typeProperty]);\n return {\n id: relationshipHash,\n type: type\n };\n }\n return this._super(...arguments);\n }\n });\n if (true /* DEBUG */) {\n RESTSerializer.reopen({\n warnMessageNoModelForKey(prop, typeKey) {\n return 'Encountered \"' + prop + '\" in payload, but no model was found for model name \"' + typeKey + '\" (resolved model name using ' + this.constructor.toString() + '.modelNameFromPayloadKey(\"' + prop + '\"))';\n }\n });\n }\n var _default = _exports.default = RESTSerializer;\n});","define(\"@ember-data/serializer/transform\", [\"exports\", \"@ember-data/serializer/-private\"], function (_exports, _private) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.default = void 0;\n 0; //eaimeta@70e063a35619d71f0,\"@ember-data/serializer/-private\"eaimeta@70e063a35619d71f\n /**\n @module @ember-data/serializer\n */\n var _default = _exports.default = _private.Transform;\n});","define(\"@ember-data/store/-debug/index\", [\"exports\", \"@ember/debug\"], function (_exports, _debug) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.assertPolymorphicType = void 0;\n 0; //eaimeta@70e063a35619d71f0,\"@ember/debug\",0,\"@glimmer/env\"eaimeta@70e063a35619d71f\n /*\n Assert that `addedRecord` has a valid type so it can be added to the\n relationship of the `record`.\n \n The assert basically checks if the `addedRecord` can be added to the\n relationship (specified via `relationshipMeta`) of the `record`.\n \n This utility should only be used internally, as both record parameters must\n be an InternalModel and the `relationshipMeta` needs to be the meta\n information about the relationship, retrieved via\n `record.relationshipFor(key)`.\n */\n let assertPolymorphicType = _exports.assertPolymorphicType = void 0;\n if (true /* DEBUG */) {\n let checkPolymorphic = function checkPolymorphic(modelClass, addedModelClass) {\n if (modelClass.__isMixin) {\n return modelClass.__mixin.detect(addedModelClass.PrototypeMixin) ||\n // handle native class extension e.g. `class Post extends Model.extend(Commentable) {}`\n modelClass.__mixin.detect(Object.getPrototypeOf(addedModelClass).PrototypeMixin);\n }\n return addedModelClass.prototype instanceof modelClass || modelClass.detect(addedModelClass);\n };\n _exports.assertPolymorphicType = assertPolymorphicType = function assertPolymorphicType(parentIdentifier, parentDefinition, addedIdentifier, store) {\n store = store._store ? store._store : store; // allow usage with storeWrapper\n let addedModelName = addedIdentifier.type;\n let parentModelName = parentIdentifier.type;\n let key = parentDefinition.key;\n let relationshipModelName = parentDefinition.type;\n let relationshipClass = store.modelFor(relationshipModelName);\n let addedClass = store.modelFor(addedModelName);\n let assertionMessage = `The '${addedModelName}' type does not implement '${relationshipModelName}' and thus cannot be assigned to the '${key}' relationship in '${parentModelName}'. Make it a descendant of '${relationshipModelName}' or use a mixin of the same name.`;\n let isPolymorphic = checkPolymorphic(relationshipClass, addedClass);\n (true && !(isPolymorphic) && (0, _debug.assert)(assertionMessage, isPolymorphic));\n };\n }\n});","define('@ember-data/store/-private', ['exports', '@ember/application', '@ember/debug', '@ember/error', '@ember/utils', '@ember/array', '@ember/object', '@ember/runloop', '@ember/service', '@ember/test', 'ember', 'require', 'rsvp', '@ember/string', '@ember/array/proxy', '@ember/object/computed', '@ember/object/promise-proxy-mixin', '@ember/object/proxy', '@ember/object/compat', '@glimmer/tracking', 'ember-cached-decorator-polyfill', '@ember-data/store/-debug'], (function (exports, application, debug, EmberError, utils, EmberArray, object, runloop, Service, test, Ember, require$1, RSVP, string, ArrayProxy, computed, PromiseProxyMixin, ObjectProxy, compat, tracking, emberCachedDecoratorPolyfill, Debug) { 'use strict';\n\n function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }\n\n var EmberError__default = /*#__PURE__*/_interopDefaultLegacy(EmberError);\n var EmberArray__default = /*#__PURE__*/_interopDefaultLegacy(EmberArray);\n var Service__default = /*#__PURE__*/_interopDefaultLegacy(Service);\n var Ember__default = /*#__PURE__*/_interopDefaultLegacy(Ember);\n var require__default = /*#__PURE__*/_interopDefaultLegacy(require$1);\n var RSVP__default = /*#__PURE__*/_interopDefaultLegacy(RSVP);\n var ArrayProxy__default = /*#__PURE__*/_interopDefaultLegacy(ArrayProxy);\n var PromiseProxyMixin__default = /*#__PURE__*/_interopDefaultLegacy(PromiseProxyMixin);\n var ObjectProxy__default = /*#__PURE__*/_interopDefaultLegacy(ObjectProxy);\n\n /**\n @module @ember-data/store\n */\n\n // Used by the store to normalize IDs entering the store. Despite the fact\n // that developers may provide IDs as numbers (e.g., `store.findRecord('person', 1)`),\n // it is important that internally we use strings, since IDs may be serialized\n // and lose type information. For example, Ember's router may put a record's\n // ID into the URL, and if we later try to deserialize that URL and find the\n // corresponding record, we will not know if it is a string or a number.\n\n function coerceId(id) {\n if (id === null || id === undefined || id === '') {\n return null;\n }\n if (typeof id === 'string') {\n return id;\n }\n if (typeof id === 'symbol') {\n return id.toString();\n }\n return '' + id;\n }\n function ensureStringId(id) {\n let normalized = null;\n if (typeof id === 'string') {\n normalized = id.length > 0 ? id : null;\n } else if (typeof id === 'number' && !isNaN(id)) {\n normalized = '' + id;\n }\n if (normalized === null) {\n throw new Error(`Expected id to be a string or number, received ${String(id)}`);\n }\n return normalized;\n }\n\n /**\n @module @ember-data/store\n */\n\n // All modelNames are dasherized internally. Changing this function may\n // require changes to other normalization hooks (such as typeForRoot).\n\n /**\n This method normalizes a modelName into the format Ember Data uses\n internally by dasherizing it.\n\n @method normalizeModelName\n @static\n @public\n @for @ember-data/store\n @param {String} modelName\n @return {String} normalizedModelName\n */\n function normalizeModelName(modelName) {\n return string.dasherize(modelName);\n }\n\n /**\n @module @ember-data/store\n */\n\n // provided for additional debuggability\n const DEBUG_CLIENT_ORIGINATED = Symbol('record-originated-on-client');\n const DEBUG_IDENTIFIER_BUCKET = Symbol('identifier-bucket');\n\n /**\n * An Identifier specific to a record which may or may not\n * be present in the cache.\n *\n * The absence of an `id` DOES NOT indicate that this\n * Identifier is for a new client-created record as it\n * may also indicate that it was generated for a secondary\n * index and the primary `id` index is not yet known.\n *\n * @internal\n */\n\n /**\n * Used when an Identifier is known to be the stable version\n *\n * @internal\n */\n\n /**\n * Used when a StableRecordIdentifier was not created locally as part\n * of a call to store.createRecord\n *\n * Distinguishing between this Identifier and one for a client created\n * record that was created with an ID is generally speaking not possible\n * at runtime, so anything with an ID typically narrows to this.\n *\n * @internal\n */\n\n /**\n * Used when a StableRecordIdentifier was created locally\n * (by a call to store.createRecord).\n *\n * It is possible in rare circumstances to have a StableRecordIdentifier\n * that is not for a new record but does not have an ID. This would\n * happen if a user intentionally created one for use with a secondary-index\n * prior to the record having been fully loaded.\n *\n * @internal\n */\n\n /**\n * A referentially stable object with a unique string (lid) that can be used\n * as a reference to data in the cache.\n *\n * Every record instance has a unique identifier, and identifiers may refer\n * to data that has never been loaded (for instance, in an async relationship).\n *\n * @class StableRecordIdentifier\n * @public\n */\n\n /**\n * A string representing a unique identity.\n *\n * @property {string} lid\n * @public\n */\n /**\n * the primary resource `type` or `modelName` this identity belongs to.\n *\n * @property {string} type\n * @public\n */\n /**\n * the primary id for the record this identity belongs to. `null`\n * if not yet assigned an id.\n *\n * @property {string | null} id\n * @public\n */\n\n /**\n Configures how unique identifier lid strings are generated by @ember-data/store.\n\n This configuration MUST occur prior to the store instance being created.\n\n Takes a method which can expect to receive various data as its first argument\n and the name of a bucket as its second argument. Currently the second\n argument will always be `record` data should conform to a `json-api`\n `Resource` interface, but will be the normalized json data for a single\n resource that has been given to the store.\n\n The method must return a unique (to at-least the given bucket) string identifier\n for the given data as a string to be used as the `lid` of an `Identifier` token.\n\n This method will only be called by either `getOrCreateRecordIdentifier` or\n `createIdentifierForNewRecord` when an identifier for the supplied data\n is not already known via `lid` or `type + id` combo and one needs to be\n generated or retrieved from a proprietary cache.\n\n `data` will be the same data argument provided to `getOrCreateRecordIdentifier`\n and in the `createIdentifierForNewRecord` case will be an object with\n only `type` as a key.\n\n ```ts\n import { setIdentifierGenerationMethod } form '@ember-data/store';\n\n export function initialize(applicationInstance) {\n // note how `count` here is now scoped to the application instance\n // for our generation method by being inside the closure provided\n // by the initialize function\n let count = 0;\n\n setIdentifierGenerationMethod((resource, bucket) => {\n return resource.lid || `my-key-${count++}`;\n });\n }\n\n export default {\n name: 'configure-ember-data-identifiers',\n initialize\n };\n ```\n\n @method setIdentifierGenerationMethod\n @for @ember-data/store\n @param method\n @public\n @static\n */\n\n /**\n Configure a callback for when the identifier cache encounters new resource\n data for an existing resource.\n\n This configuration MUST occur prior to the store instance being created.\n\n ```js\n import { setIdentifierUpdateMethod } from '@ember-data/store';\n ```\n\n Takes a method which can expect to receive an existing `Identifier` alongside\n some new data to consider as a second argument. This is an opportunity\n for secondary lookup tables and caches associated with the identifier\n to be amended.\n\n This method is called everytime `updateRecordIdentifier` is called and\n with the same arguments. It provides the opportunity to update secondary\n lookup tables for existing identifiers.\n\n It will always be called after an identifier created with `createIdentifierForNewRecord`\n has been committed, or after an update to the `record` a `RecordIdentifier`\n is assigned to has been committed. Committed here meaning that the server\n has acknowledged the update (for instance after a call to `.save()`)\n\n If `id` has not previously existed, it will be assigned to the `Identifier`\n prior to this `UpdateMethod` being called; however, calls to the parent method\n `updateRecordIdentifier` that attempt to change the `id` or calling update\n without providing an `id` when one is missing will throw an error.\n\n @method setIdentifierUpdateMethod\n @for @ember-data/store\n @param method\n @public\n @static\n */\n\n /**\n Configure a callback for when the identifier cache is going to release an identifier.\n\n This configuration MUST occur prior to the store instance being created.\n\n ```js\n import { setIdentifierForgetMethod } from '@ember-data/store';\n ```\n\n Takes method which can expect to receive an existing `Identifier` that should be eliminated\n from any secondary lookup tables or caches that the user has populated for it.\n\n @method setIdentifierForgetMethod\n @for @ember-data/store\n @param method\n @public\n @static\n */\n\n /**\n Configure a callback for when the identifier cache is being torn down.\n\n This configuration MUST occur prior to the store instance being created.\n\n ```js\n import { setIdentifierResetMethod } from '@ember-data/store';\n ```\n\n Takes a method which can expect to be called when the parent application is destroyed.\n\n If you have properly used a WeakMap to encapsulate the state of your customization\n to the application instance, you may not need to implement the `resetMethod`.\n\n @method setIdentifierResetMethod\n @for @ember-data/store\n @param method\n @public\n @static\n */\n\n /*\n DEBUG only fields. Keeping this in a separate interface\n which Typescript then merges with the class definition allow us to\n have a DEBUG only property without paying the cost of that field being\n present and initialized (usually to void 0) in production.\n */\n\n /**\n * @class WeakCache\n * @extends WeakMap\n * @internal\n */\n class WeakCache extends WeakMap {\n constructor(_fieldName) {\n super();\n {\n this._fieldName = _fieldName;\n this._symbol = Symbol.for(_fieldName);\n }\n }\n\n /**\n * Retrieve the value for a key from the WeakCache with the expectation\n * that the key exists. Throws the error generated by _expectMsg in DEBUG if\n * that key does not exist.\n *\n * @method getWithError\n * @param obj\n * @internal\n */\n getWithError(obj) {\n let v = this.get(obj);\n if (v === undefined) {\n throw new Error(this._expectMsg(obj));\n }\n return v;\n }\n\n /**\n * Retrieve the value for a key from the WeakCache, or generate one\n * using the configured _generator method if no value is yet present.\n *\n * @method lookup\n * @param obj\n * @internal\n */\n lookup(obj) {\n let v = super.get(obj);\n if (v === undefined) {\n v = this._generator(obj);\n super.set(obj, v);\n {\n if (obj[DEBUG_IDENTIFIER_BUCKET] && this._fieldName !== 'identifier-proxy-target') {\n const target = obj[Symbol.for('identifier-proxy-target')];\n target[this._symbol] = v;\n } else {\n obj[this._symbol] = v;\n }\n }\n }\n return v;\n }\n }\n class DebugWeakCache extends WeakCache {\n set(obj, value) {\n if (super.has(obj)) {\n throw new Error(`${Object.prototype.toString.call(obj)} was already assigned a value for ${this._fieldName}`);\n }\n {\n if (obj[DEBUG_IDENTIFIER_BUCKET] && this._fieldName !== 'identifier-proxy-target') {\n const target = obj[Symbol.for('identifier-proxy-target')];\n target[this._symbol] = value;\n // TODO the Proxy check here is entirely for ember-m3\n // as it's attribute access tests fail since the symbol\n // is an unexpected key received by it's proxies.\n // we should address this upstream.\n } else if (obj.constructor?.toString?.() !== 'MegamorphicModel') {\n try {\n obj[this._symbol] = value;\n } catch {\n // some keys are proxies that can't accept symbol values\n // for instance records from ember-m3\n }\n }\n }\n return super.set(obj, value);\n }\n }\n var WeakCache$1 = DebugWeakCache ;\n\n function isNonEmptyString(str) {\n return typeof str === 'string' && str.length > 0;\n }\n\n /**\n @module @ember-data/store\n */\n\n const IDENTIFIERS = new WeakSet();\n function isStableIdentifier(identifier) {\n return IDENTIFIERS.has(identifier);\n }\n function markStableIdentifier(identifier) {\n IDENTIFIERS.add(identifier);\n }\n function unmarkStableIdentifier(identifier) {\n IDENTIFIERS.delete(identifier);\n }\n\n /**\n @module @ember-data/store\n */\n\n const CRYPTO = (() => {\n const hasWindow = typeof window !== 'undefined';\n const isFastBoot = typeof FastBoot !== 'undefined';\n if (isFastBoot) {\n return {\n getRandomValues(buffer) {\n try {\n return FastBoot.require('crypto').randomFillSync(buffer);\n } catch (err) {\n throw new Error('Using createRecord in Fastboot requires you to add the \"crypto\" package to \"fastbootDependencies\" in your package.json');\n }\n }\n };\n } else if (hasWindow && typeof window.crypto !== 'undefined') {\n return window.crypto;\n } else {\n throw new Error('ember-data: Cannot find a valid way to generate local identifiers');\n }\n })();\n\n // we might be able to optimize this by requesting more bytes than we need at a time\n function rng() {\n // WHATWG crypto RNG - http://wiki.whatwg.org/wiki/Crypto\n let rnds8 = new Uint8Array(16);\n return CRYPTO.getRandomValues(rnds8);\n }\n\n /*\n * Convert array of 16 byte values to UUID string format of the form:\n * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX\n */\n const byteToHex = [];\n for (let i = 0; i < 256; ++i) {\n byteToHex[i] = (i + 0x100).toString(16).substr(1);\n }\n function bytesToUuid(buf) {\n let bth = byteToHex;\n // join used to fix memory issue caused by concatenation: https://bugs.chromium.org/p/v8/issues/detail?id=3175#c4\n return [bth[buf[0]], bth[buf[1]], bth[buf[2]], bth[buf[3]], '-', bth[buf[4]], bth[buf[5]], '-', bth[buf[6]], bth[buf[7]], '-', bth[buf[8]], bth[buf[9]], '-', bth[buf[10]], bth[buf[11]], bth[buf[12]], bth[buf[13]], bth[buf[14]], bth[buf[15]]].join('');\n }\n function uuidv4() {\n let rnds = rng();\n\n // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`\n rnds[6] = rnds[6] & 0x0f | 0x40;\n rnds[8] = rnds[8] & 0x3f | 0x80;\n return bytesToUuid(rnds);\n }\n\n function freeze$1(obj) {\n if (typeof Object.freeze === 'function') {\n return Object.freeze(obj);\n }\n return obj;\n }\n let configuredForgetMethod;\n let configuredGenerationMethod;\n let configuredResetMethod;\n let configuredUpdateMethod;\n function setIdentifierGenerationMethod(method) {\n configuredGenerationMethod = method;\n }\n function setIdentifierUpdateMethod(method) {\n configuredUpdateMethod = method;\n }\n function setIdentifierForgetMethod(method) {\n configuredForgetMethod = method;\n }\n function setIdentifierResetMethod(method) {\n configuredResetMethod = method;\n }\n function defaultGenerationMethod(data, bucket) {\n if ('lid' in data && isNonEmptyString(data.lid)) {\n return data.lid;\n }\n if ('id' in data) {\n let {\n type,\n id\n } = data;\n // TODO: add test for id not a string\n if (isNonEmptyString(coerceId(id))) {\n return `@ember-data:lid-${normalizeModelName(type)}-${id}`;\n }\n }\n return uuidv4();\n }\n function defaultEmptyCallback(...args) {}\n let DEBUG_MAP;\n {\n DEBUG_MAP = new WeakCache$1('identifier-proxy-target');\n }\n\n /**\n * Each instance of {Store} receives a unique instance of a IdentifierCache.\n *\n * This cache is responsible for assigning or retrieving the unique identify\n * for arbitrary resource data encountered by the store. Data representing\n * a unique resource or record should always be represented by the same\n * identifier.\n *\n * It can be configured by consuming applications.\n *\n * @class IdentifierCache\n @public\n */\n class IdentifierCache {\n constructor() {\n // Typescript still leaks private properties in the final\n // compiled class, so we may want to move these from _underscore\n // to a WeakMap to avoid leaking\n // currently we leak this for test purposes\n this._cache = {\n lids: Object.create(null),\n types: Object.create(null)\n };\n this._generate = void 0;\n this._update = void 0;\n this._forget = void 0;\n this._reset = void 0;\n this._merge = void 0;\n // we cache the user configuredGenerationMethod at init because it must\n // be configured prior and is not allowed to be changed\n this._generate = configuredGenerationMethod || defaultGenerationMethod;\n this._update = configuredUpdateMethod || defaultEmptyCallback;\n this._forget = configuredForgetMethod || defaultEmptyCallback;\n this._reset = configuredResetMethod || defaultEmptyCallback;\n this._merge = defaultEmptyCallback;\n }\n\n /**\n * Internal hook to allow management of merge conflicts with identifiers.\n *\n * we allow late binding of this private internal merge so that `internalModelFactory`\n * can insert itself here to handle elimination of duplicates\n *\n * @method __configureMerge\n * @private\n */\n __configureMerge(method) {\n this._merge = method || defaultEmptyCallback;\n }\n\n /**\n * @method _getRecordIdentifier\n * @private\n */\n\n _getRecordIdentifier(resource, shouldGenerate = false) {\n // short circuit if we're already the stable version\n if (isStableIdentifier(resource)) {\n {\n // TODO should we instead just treat this case as a new generation skipping the short circuit?\n if (!(resource.lid in this._cache.lids) || this._cache.lids[resource.lid] !== resource) {\n throw new Error(`The supplied identifier ${resource} does not belong to this store instance`);\n }\n }\n return resource;\n }\n let lid = coerceId(resource.lid);\n let identifier = lid !== null ? this._cache.lids[lid] : undefined;\n if (identifier !== undefined) {\n return identifier;\n }\n if (shouldGenerate === false) {\n if (!('type' in resource) || !('id' in resource) || !resource.type || !resource.id) {\n return;\n }\n }\n\n // `type` must always be present\n (!('type' in resource && isNonEmptyString(resource.type)) && debug.assert('resource.type needs to be a string', 'type' in resource && isNonEmptyString(resource.type)));\n let type = resource.type && normalizeModelName(resource.type);\n let id = coerceId(resource.id);\n let keyOptions = getTypeIndex(this._cache.types, type);\n\n // go straight for the stable RecordIdentifier key'd to `lid`\n if (lid !== null) {\n identifier = keyOptions.lid[lid];\n }\n\n // we may have not seen this resource before\n // but just in case we check our own secondary lookup (`id`)\n if (identifier === undefined && id !== null) {\n identifier = keyOptions.id[id];\n }\n if (identifier === undefined) {\n // we have definitely not seen this resource before\n // so we allow the user configured `GenerationMethod` to tell us\n let newLid = this._generate(resource, 'record');\n\n // we do this _even_ when `lid` is present because secondary lookups\n // may need to be populated, but we enforce not giving us something\n // different than expected\n if (lid !== null && newLid !== lid) {\n throw new Error(`You should not change the of a RecordIdentifier`);\n } else if (lid === null) {\n // allow configuration to tell us that we have\n // seen this `lid` before. E.g. a secondary lookup\n // connects this resource to a previously seen\n // resource.\n identifier = keyOptions.lid[newLid];\n }\n if (shouldGenerate === true) {\n if (identifier === undefined) {\n // if we still don't have an identifier, time to generate one\n identifier = makeStableRecordIdentifier(id, type, newLid, 'record', false);\n\n // populate our unique table\n {\n // realistically if you hit this it means you changed `type` :/\n // TODO consider how to handle type change assertions more gracefully\n if (identifier.lid in this._cache.lids) {\n throw new Error(`You should not change the of a RecordIdentifier`);\n }\n }\n this._cache.lids[identifier.lid] = identifier;\n\n // populate our primary lookup table\n // TODO consider having the `lid` cache be\n // one level up\n keyOptions.lid[identifier.lid] = identifier;\n // TODO exists temporarily to support `peekAll`\n // but likely to move\n keyOptions._allIdentifiers.push(identifier);\n }\n\n // populate our own secondary lookup table\n // even for the \"successful\" secondary lookup\n // by `_generate()`, since we missed the cache\n // previously\n // we use identifier.id instead of id here\n // because they may not match and we prefer\n // what we've set via resource data\n if (identifier.id !== null) {\n keyOptions.id[identifier.id] = identifier;\n\n // TODO allow filling out of `id` here\n // for the `username` non-client created\n // case.\n }\n }\n }\n return identifier;\n }\n\n /**\n * allows us to peek without generating when needed\n * useful for the \"create\" case when we need to see if\n * we are accidentally overwritting something\n *\n * @method peekRecordIdentifier\n * @param resource\n * @returns {StableRecordIdentifier | undefined}\n * @private\n */\n peekRecordIdentifier(resource) {\n return this._getRecordIdentifier(resource, false);\n }\n\n /**\n Returns the Identifier for the given Resource, creates one if it does not yet exist.\n Specifically this means that we:\n - validate the `id` `type` and `lid` combo against known identifiers\n - return an object with an `lid` that is stable (repeated calls with the same\n `id` + `type` or `lid` will return the same `lid` value)\n - this referential stability of the object itself is guaranteed\n @method getOrCreateRecordIdentifier\n @param resource\n @returns {StableRecordIdentifier}\n @public\n */\n getOrCreateRecordIdentifier(resource) {\n return this._getRecordIdentifier(resource, true);\n }\n\n /**\n Returns a new Identifier for the supplied data. Call this method to generate\n an identifier when a new resource is being created local to the client and\n potentially does not have an `id`.\n Delegates generation to the user supplied `GenerateMethod` if one has been provided\n with the signature `generateMethod({ type }, 'record')`.\n @method createIdentifierForNewRecord\n @param data\n @returns {StableRecordIdentifier}\n @public\n */\n createIdentifierForNewRecord(data) {\n let newLid = this._generate(data, 'record');\n let identifier = makeStableRecordIdentifier(data.id || null, data.type, newLid, 'record', true);\n let keyOptions = getTypeIndex(this._cache.types, data.type);\n\n // populate our unique table\n {\n if (identifier.lid in this._cache.lids) {\n throw new Error(`The lid generated for the new record is not unique as it matches an existing identifier`);\n }\n }\n this._cache.lids[identifier.lid] = identifier;\n\n // populate the type+lid cache\n keyOptions.lid[newLid] = identifier;\n // ensure a peekAll sees our new identifier too\n // TODO move this outta here?\n keyOptions._allIdentifiers.push(identifier);\n return identifier;\n }\n\n /**\n Provides the opportunity to update secondary lookup tables for existing identifiers\n Called after an identifier created with `createIdentifierForNewRecord` has been\n committed.\n Assigned `id` to an `Identifier` if `id` has not previously existed; however,\n attempting to change the `id` or calling update without providing an `id` when\n one is missing will throw an error.\n - sets `id` (if `id` was previously `null`)\n - `lid` and `type` MUST NOT be altered post creation\n If a merge occurs, it is possible the returned identifier does not match the originally\n provided identifier. In this case the abandoned identifier will go through the usual\n `forgetRecordIdentifier` codepaths.\n @method updateRecordIdentifier\n @param identifierObject\n @param data\n @returns {StableRecordIdentifier}\n @public\n */\n updateRecordIdentifier(identifierObject, data) {\n let identifier = this.getOrCreateRecordIdentifier(identifierObject);\n let newId = 'id' in data ? coerceId(data.id) : null;\n let existingIdentifier = detectMerge(this._cache.types, identifier, data, newId, this._cache.lids);\n if (!existingIdentifier) {\n // If the incoming type does not match the identifier type, we need to create an identifier for the incoming\n // data so we can merge the incoming data with the existing identifier, see #7325 and #7363\n if ('type' in data && data.type && identifier.type !== normalizeModelName(data.type)) {\n let incomingDataResource = {\n ...data\n };\n // Need to strip the lid from the incomingData in order force a new identifier creation\n delete incomingDataResource.lid;\n existingIdentifier = this.getOrCreateRecordIdentifier(incomingDataResource);\n }\n }\n if (existingIdentifier) {\n let keyOptions = getTypeIndex(this._cache.types, identifier.type);\n identifier = this._mergeRecordIdentifiers(keyOptions, identifier, existingIdentifier, data, newId);\n }\n let id = identifier.id;\n performRecordIdentifierUpdate(identifier, data, this._update);\n newId = identifier.id;\n\n // add to our own secondary lookup table\n if (id !== newId && newId !== null) {\n let keyOptions = getTypeIndex(this._cache.types, identifier.type);\n keyOptions.id[newId] = identifier;\n if (id !== null) {\n delete keyOptions.id[id];\n }\n }\n return identifier;\n }\n\n /**\n * @method _mergeRecordIdentifiers\n * @private\n */\n _mergeRecordIdentifiers(keyOptions, identifier, existingIdentifier, data, newId) {\n // delegate determining which identifier to keep to the configured MergeMethod\n let kept = this._merge(identifier, existingIdentifier, data);\n let abandoned = kept === identifier ? existingIdentifier : identifier;\n\n // cleanup the identifier we no longer need\n this.forgetRecordIdentifier(abandoned);\n\n // ensure a secondary cache entry for this id for the identifier we do keep\n keyOptions.id[newId] = kept;\n // ensure a secondary cache entry for this id for the abandoned identifier's type we do keep\n let baseKeyOptions = getTypeIndex(this._cache.types, existingIdentifier.type);\n baseKeyOptions.id[newId] = kept;\n\n // make sure that the `lid` on the data we are processing matches the lid we kept\n data.lid = kept.lid;\n return kept;\n }\n\n /**\n Provides the opportunity to eliminate an identifier from secondary lookup tables\n as well as eliminates it from ember-data's own lookup tables and book keeping.\n Useful when a record has been deleted and the deletion has been persisted and\n we do not care about the record anymore. Especially useful when an `id` of a\n deleted record might be reused later for a new record.\n @method forgetRecordIdentifier\n @param identifierObject\n @public\n */\n forgetRecordIdentifier(identifierObject) {\n let identifier = this.getOrCreateRecordIdentifier(identifierObject);\n let keyOptions = getTypeIndex(this._cache.types, identifier.type);\n if (identifier.id !== null) {\n delete keyOptions.id[identifier.id];\n }\n delete this._cache.lids[identifier.lid];\n delete keyOptions.lid[identifier.lid];\n let index = keyOptions._allIdentifiers.indexOf(identifier);\n keyOptions._allIdentifiers.splice(index, 1);\n unmarkStableIdentifier(identifierObject);\n this._forget(identifier, 'record');\n }\n destroy() {\n this._reset();\n }\n }\n function getTypeIndex(typeMap, type) {\n let typeIndex = typeMap[type];\n if (typeIndex === undefined) {\n typeIndex = {\n lid: Object.create(null),\n id: Object.create(null),\n _allIdentifiers: []\n };\n typeMap[type] = typeIndex;\n }\n return typeIndex;\n }\n function makeStableRecordIdentifier(id, type, lid, bucket, clientOriginated = false) {\n let recordIdentifier = {\n lid,\n id,\n type\n };\n markStableIdentifier(recordIdentifier);\n {\n // we enforce immutability in dev\n // but preserve our ability to do controlled updates to the reference\n let wrapper = {\n get lid() {\n return recordIdentifier.lid;\n },\n get id() {\n return recordIdentifier.id;\n },\n get type() {\n return recordIdentifier.type;\n },\n toString() {\n let {\n type,\n id,\n lid\n } = recordIdentifier;\n return `${clientOriginated ? '[CLIENT_ORIGINATED] ' : ''}${type}:${id} (${lid})`;\n }\n };\n wrapper[DEBUG_CLIENT_ORIGINATED] = clientOriginated;\n wrapper[DEBUG_IDENTIFIER_BUCKET] = bucket;\n markStableIdentifier(wrapper);\n DEBUG_MAP.set(wrapper, recordIdentifier);\n wrapper = freeze$1(wrapper);\n return wrapper;\n }\n }\n function performRecordIdentifierUpdate(identifier, data, updateFn) {\n {\n let {\n lid\n } = data;\n let id = 'id' in data ? data.id : undefined;\n let type = 'type' in data && data.type && normalizeModelName(data.type);\n\n // get the mutable instance behind our proxy wrapper\n let wrapper = identifier;\n identifier = DEBUG_MAP.get(wrapper);\n if (lid !== undefined) {\n let newLid = coerceId(lid);\n if (newLid !== identifier.lid) {\n throw new Error(`The 'lid' for a RecordIdentifier cannot be updated once it has been created. Attempted to set lid for '${wrapper}' to '${lid}'.`);\n }\n }\n if (id !== undefined) {\n let newId = coerceId(id);\n if (identifier.id !== null && identifier.id !== newId) {\n // here we warn and ignore, as this may be a mistake, but we allow the user\n // to have multiple cache-keys pointing at a single lid so we cannot error\n (debug.warn(`The 'id' for a RecordIdentifier should not be updated once it has been set. Attempted to set id for '${wrapper}' to '${newId}'.`, false, {\n id: 'ember-data:multiple-ids-for-identifier'\n }));\n }\n }\n\n // TODO consider just ignoring here to allow flexible polymorphic support\n if (type && type !== identifier.type) {\n throw new Error(`The 'type' for a RecordIdentifier cannot be updated once it has been set. Attempted to set type for '${wrapper}' to '${type}'.`);\n }\n updateFn(wrapper, data, 'record');\n }\n\n // upgrade the ID, this is a \"one time only\" ability\n // for the multiple-cache-key scenario we \"could\"\n // use a heuristic to guess the best id for display\n // (usually when `data.id` is available and `data.attributes` is not)\n if ('id' in data && data.id !== undefined) {\n identifier.id = coerceId(data.id);\n }\n }\n function detectMerge(typesCache, identifier, data, newId, lids) {\n const {\n id,\n type,\n lid\n } = identifier;\n if (id !== null && id !== newId && newId !== null) {\n let keyOptions = getTypeIndex(typesCache, identifier.type);\n let existingIdentifier = keyOptions.id[newId];\n return existingIdentifier !== undefined ? existingIdentifier : false;\n } else {\n let newType = 'type' in data && data.type && normalizeModelName(data.type);\n\n // If the ids and type are the same but lid is not the same, we should trigger a merge of the identifiers\n if (id !== null && id === newId && newType === type && data.lid && data.lid !== lid) {\n let existingIdentifier = lids[data.lid];\n return existingIdentifier !== undefined ? existingIdentifier : false;\n // If the lids are the same, and ids are the same, but types are different we should trigger a merge of the identifiers\n } else if (id !== null && id === newId && newType && newType !== type && data.lid && data.lid === lid) {\n let keyOptions = getTypeIndex(typesCache, newType);\n let existingIdentifier = keyOptions.id[id];\n return existingIdentifier !== undefined ? existingIdentifier : false;\n }\n }\n return false;\n }\n\n function constructResource(type, id, lid) {\n if (typeof type === 'object' && type !== null) {\n let resource = type;\n if (isStableIdentifier(resource)) {\n return resource;\n }\n if ('id' in resource) {\n resource.id = coerceId(resource.id);\n }\n (!('id' in resource && isNonEmptyString(resource.id) || isNonEmptyString(resource.lid)) && debug.assert('Expected either id or lid to be a valid string', 'id' in resource && isNonEmptyString(resource.id) || isNonEmptyString(resource.lid)));\n (!(!('id' in resource) || typeof resource.type === 'string') && debug.assert('if id is present, the type must be a string', !('id' in resource) || typeof resource.type === 'string'));\n return resource;\n } else {\n const trueId = coerceId(id);\n if (!isNonEmptyString(trueId)) {\n if (isNonEmptyString(lid)) {\n return {\n lid\n };\n }\n throw new Error('Expected either id or lid to be a valid string');\n }\n (!(typeof type === 'string') && debug.assert('type must be a string', typeof type === 'string'));\n if (isNonEmptyString(lid)) {\n return {\n type,\n id: trueId,\n lid\n };\n }\n return {\n type,\n id: trueId\n };\n }\n }\n\n /**\n @module @ember-data/store\n */\n\n /**\n A `PromiseArray` is an object that acts like both an `Ember.Array`\n and a promise. When the promise is resolved the resulting value\n will be set to the `PromiseArray`'s `content` property. This makes\n it easy to create data bindings with the `PromiseArray` that will be\n updated when the promise resolves.\n\n This class should not be imported and instantiated directly.\n\n For more information see the [Ember.PromiseProxyMixin\n documentation](/ember/release/classes/PromiseProxyMixin).\n\n Example\n\n ```javascript\n let promiseArray = PromiseArray.create({\n promise: $.getJSON('/some/remote/data.json')\n });\n\n promiseArray.get('length'); // 0\n\n promiseArray.then(function() {\n promiseArray.get('length'); // 100\n });\n ```\n\n @class PromiseArray\n @public\n @extends Ember.ArrayProxy\n @uses Ember.PromiseProxyMixin\n */\n const PromiseArray = ArrayProxy__default[\"default\"].extend(PromiseProxyMixin__default[\"default\"], {\n meta: computed.reads('content.meta')\n });\n\n /**\n A `PromiseObject` is an object that acts like both an `EmberObject`\n and a promise. When the promise is resolved, then the resulting value\n will be set to the `PromiseObject`'s `content` property. This makes\n it easy to create data bindings with the `PromiseObject` that will\n be updated when the promise resolves.\n\n This class should not be imported and instantiated directly.\n\n For more information see the [Ember.PromiseProxyMixin\n documentation](/ember/release/classes/PromiseProxyMixin.html).\n\n Example\n\n ```javascript\n let promiseObject = PromiseObject.create({\n promise: $.getJSON('/some/remote/data.json')\n });\n\n promiseObject.get('name'); // null\n\n promiseObject.then(function() {\n promiseObject.get('name'); // 'Tomster'\n });\n ```\n\n @class PromiseObject\n @public\n @extends Ember.ObjectProxy\n @uses Ember.PromiseProxyMixin\n */\n let PromiseObject = ObjectProxy__default[\"default\"].extend(PromiseProxyMixin__default[\"default\"]);\n function promiseObject(promise, label) {\n return PromiseObject.create({\n promise: RSVP.Promise.resolve(promise, label)\n });\n }\n function promiseArray(promise, label) {\n return PromiseArray.create({\n promise: RSVP.Promise.resolve(promise, label)\n });\n }\n\n // constructor is accessed in some internals but not including it in the copyright for the deprecation\n const ALLOWABLE_METHODS = ['constructor', 'then', 'catch', 'finally'];\n const ALLOWABLE_PROPS = ['__ec_yieldable__', '__ec_cancel__'];\n function deprecatedPromiseObject(promise) {\n const handler = {\n get(target, prop) {\n if (ALLOWABLE_PROPS.includes(prop)) {\n return target[prop];\n }\n if (!ALLOWABLE_METHODS.includes(prop)) {\n (debug.deprecate(`Accessing ${prop} is deprecated. Only available methods to access on a promise returned from model.save() are .then, .catch and .finally`, false, {\n id: 'ember-data:model-save-promise',\n until: '5.0',\n for: '@ember-data/store',\n since: {\n available: '4.4',\n enabled: '4.4'\n }\n }));\n }\n\n /* global Reflect */\n return Reflect.get(...arguments).bind(target);\n }\n };\n\n /* global Proxy */\n return new Proxy(promise, handler);\n }\n\n /**\n @module @ember-data/store\n */\n\n /**\n * Get the materialized model from the internalModel/promise\n * that returns an internal model and return it in a promiseObject.\n *\n * Useful for returning from find methods\n *\n * @internal\n */\n function promiseRecord(internalModelPromise, label) {\n let toReturn = internalModelPromise.then(internalModel => internalModel.getRecord());\n return promiseObject(toReturn, label);\n }\n\n // TODO: expose Ember._Backburner as `import { _Backburner } from '@ember/runloop'` in ember-rfc176-data + emberjs/ember.js\n /*\n syncRelationships is used by the UI to grab updates from the graph\n and update the ManyArrays.\n\n We may be able to remove this once the new relationship layer is\n complete.\n */\n const backburner = new Ember__default[\"default\"]._Backburner(['coalesce', 'sync', 'notify']);\n {\n test.registerWaiter(() => {\n return !backburner.currentInstance && !backburner.hasTimers();\n });\n }\n\n /**\n @module @ember-data/adapter/error\n */\n\n const SOURCE_POINTER_REGEXP = /^\\/?data\\/(attributes|relationships)\\/(.*)/;\n const SOURCE_POINTER_PRIMARY_REGEXP = /^\\/?data/;\n const PRIMARY_ATTRIBUTE_KEY = 'base';\n\n /**\n Convert an hash of errors into an array with errors in JSON-API format.\n ```javascript\n import DS from 'ember-data';\n\n const { errorsHashToArray } = DS;\n \n let errors = {\n base: 'Invalid attributes on saving this record',\n name: 'Must be present',\n age: ['Must be present', 'Must be a number']\n };\n let errorsArray = errorsHashToArray(errors);\n // [\n // {\n // title: \"Invalid Document\",\n // detail: \"Invalid attributes on saving this record\",\n // source: { pointer: \"/data\" }\n // },\n // {\n // title: \"Invalid Attribute\",\n // detail: \"Must be present\",\n // source: { pointer: \"/data/attributes/name\" }\n // },\n // {\n // title: \"Invalid Attribute\",\n // detail: \"Must be present\",\n // source: { pointer: \"/data/attributes/age\" }\n // },\n // {\n // title: \"Invalid Attribute\",\n // detail: \"Must be a number\",\n // source: { pointer: \"/data/attributes/age\" }\n // }\n // ]\n ```\n @method errorsHashToArray\n @for @ember-data/adapter/error\n @static\n @public\n @param {Object} errors hash with errors as properties\n @return {Array} array of errors in JSON-API format\n */\n function errorsHashToArray(errors) {\n let out = [];\n if (utils.isPresent(errors)) {\n Object.keys(errors).forEach(key => {\n let messages = EmberArray.makeArray(errors[key]);\n for (let i = 0; i < messages.length; i++) {\n let title = 'Invalid Attribute';\n let pointer = `/data/attributes/${key}`;\n if (key === PRIMARY_ATTRIBUTE_KEY) {\n title = 'Invalid Document';\n pointer = `/data`;\n }\n out.push({\n title: title,\n detail: messages[i],\n source: {\n pointer: pointer\n }\n });\n }\n });\n }\n return out;\n }\n\n /**\n Convert an array of errors in JSON-API format into an object.\n\n ```javascript\n import DS from 'ember-data';\n\n const { errorsArrayToHash } = DS;\n\n let errorsArray = [\n {\n title: 'Invalid Attribute',\n detail: 'Must be present',\n source: { pointer: '/data/attributes/name' }\n },\n {\n title: 'Invalid Attribute',\n detail: 'Must be present',\n source: { pointer: '/data/attributes/age' }\n },\n {\n title: 'Invalid Attribute',\n detail: 'Must be a number',\n source: { pointer: '/data/attributes/age' }\n }\n ];\n\n let errors = errorsArrayToHash(errorsArray);\n // {\n // \"name\": [\"Must be present\"],\n // \"age\": [\"Must be present\", \"must be a number\"]\n // }\n ```\n\n @method errorsArrayToHash\n @static\n @for @ember-data/adapter/error\n @public\n @param {Array} errors array of errors in JSON-API format\n @return {Object}\n */\n function errorsArrayToHash(errors) {\n let out = {};\n if (utils.isPresent(errors)) {\n errors.forEach(error => {\n if (error.source && error.source.pointer) {\n let key = error.source.pointer.match(SOURCE_POINTER_REGEXP);\n if (key) {\n key = key[2];\n } else if (error.source.pointer.search(SOURCE_POINTER_PRIMARY_REGEXP) !== -1) {\n key = PRIMARY_ATTRIBUTE_KEY;\n }\n if (key) {\n out[key] = out[key] || [];\n out[key].push(error.detail || error.title);\n }\n }\n });\n }\n return out;\n }\n\n let RequestStateEnum = /*#__PURE__*/function (RequestStateEnum) {\n RequestStateEnum[\"pending\"] = \"pending\";\n RequestStateEnum[\"fulfilled\"] = \"fulfilled\";\n RequestStateEnum[\"rejected\"] = \"rejected\";\n return RequestStateEnum;\n }({});\n\n const Touching = Symbol('touching');\n const RequestPromise = Symbol('promise');\n function hasRecordIdentifier(op) {\n return 'recordIdentifier' in op;\n }\n class RequestCache {\n constructor() {\n this._pending = Object.create(null);\n this._done = Object.create(null);\n this._subscriptions = Object.create(null);\n }\n enqueue(promise, queryRequest) {\n let query = queryRequest.data[0];\n if (hasRecordIdentifier(query)) {\n let lid = query.recordIdentifier.lid;\n let type = query.op === 'saveRecord' ? 'mutation' : 'query';\n if (!this._pending[lid]) {\n this._pending[lid] = [];\n }\n let request = {\n state: RequestStateEnum.pending,\n request: queryRequest,\n type\n };\n request[Touching] = [query.recordIdentifier];\n request[RequestPromise] = promise;\n this._pending[lid].push(request);\n this._triggerSubscriptions(request);\n promise.then(result => {\n this._dequeue(lid, request);\n let finalizedRequest = {\n state: RequestStateEnum.fulfilled,\n request: queryRequest,\n type,\n response: {\n data: result\n }\n };\n finalizedRequest[Touching] = request[Touching];\n this._addDone(finalizedRequest);\n this._triggerSubscriptions(finalizedRequest);\n }, error => {\n this._dequeue(lid, request);\n let finalizedRequest = {\n state: RequestStateEnum.rejected,\n request: queryRequest,\n type,\n response: {\n data: error && error.error\n }\n };\n finalizedRequest[Touching] = request[Touching];\n this._addDone(finalizedRequest);\n this._triggerSubscriptions(finalizedRequest);\n });\n }\n }\n _triggerSubscriptions(req) {\n req[Touching].forEach(identifier => {\n if (this._subscriptions[identifier.lid]) {\n this._subscriptions[identifier.lid].forEach(callback => callback(req));\n }\n });\n }\n _dequeue(lid, request) {\n this._pending[lid] = this._pending[lid].filter(req => req !== request);\n }\n _addDone(request) {\n request[Touching].forEach(identifier => {\n if (!this._done[identifier.lid]) {\n this._done[identifier.lid] = [];\n }\n // TODO add support for multiple\n let requestDataOp = request.request.data[0].op;\n this._done[identifier.lid] = this._done[identifier.lid].filter(req => {\n // TODO add support for multiple\n let data;\n if (req.request.data instanceof Array) {\n data = req.request.data[0];\n } else {\n data = req.request.data;\n }\n return data.op !== requestDataOp;\n });\n this._done[identifier.lid].push(request);\n });\n }\n subscribeForRecord(identifier, callback) {\n if (!this._subscriptions[identifier.lid]) {\n this._subscriptions[identifier.lid] = [];\n }\n this._subscriptions[identifier.lid].push(callback);\n }\n getPendingRequestsForRecord(identifier) {\n if (this._pending[identifier.lid]) {\n return this._pending[identifier.lid];\n }\n return [];\n }\n getLastRequestForRecord(identifier) {\n let requests = this._done[identifier.lid];\n if (requests) {\n return requests[requests.length - 1];\n }\n return null;\n }\n }\n\n /*\n * Returns the RecordData instance associated with a given\n * Model or InternalModel.\n *\n * Intentionally \"loose\" to allow anything with an _internalModel\n * property until InternalModel is eliminated.\n *\n * Intentionally not typed to `InternalModel` due to circular dependency\n * which that creates.\n *\n * Overtime, this should shift to a \"weakmap\" based lookup in the\n * \"Ember.getOwner(obj)\" style.\n */\n\n const RecordDataForIdentifierCache = new WeakCache$1('recordData' );\n function setRecordDataFor(identifier, recordData) {\n (!(!RecordDataForIdentifierCache.has(identifier)) && debug.assert(`Illegal set of identifier`, !RecordDataForIdentifierCache.has(identifier)));\n RecordDataForIdentifierCache.set(identifier, recordData);\n }\n function removeRecordDataFor(identifier) {\n RecordDataForIdentifierCache.delete(identifier);\n }\n function recordDataFor(instance) {\n if (RecordDataForIdentifierCache.has(instance)) {\n return RecordDataForIdentifierCache.get(instance);\n }\n let internalModel = instance._internalModel || instance.internalModel || instance;\n return internalModel._recordData || null;\n }\n\n function schemaIsDSModel(schema) {\n return schema.isModel === true;\n }\n /**\n Snapshot is not directly instantiable.\n Instances are provided to a consuming application's\n adapters and serializers for certain requests.\n\n @class Snapshot\n @public\n */\n class Snapshot {\n /**\n * @method constructor\n * @constructor\n * @private\n * @param options\n * @param identifier\n * @param _store\n */\n constructor(options, identifier, _store) {\n this.__attributes = null;\n this._belongsToRelationships = Object.create(null);\n this._belongsToIds = Object.create(null);\n this._hasManyRelationships = Object.create(null);\n this._hasManyIds = Object.create(null);\n this._store = _store;\n let internalModel = this._internalModel = _store._internalModelForResource(identifier);\n this.modelName = identifier.type;\n\n /**\n The unique RecordIdentifier associated with this Snapshot.\n @property identifier\n @public\n @type {StableRecordIdentifier}\n */\n this.identifier = identifier;\n\n /*\n If the internalModel does not yet have a record, then we are\n likely a snapshot being provided to a find request, so we\n populate __attributes lazily. Else, to preserve the \"moment\n in time\" in which a snapshot is created, we greedily grab\n the values.\n */\n if (internalModel.hasRecord) {\n this._attributes;\n }\n\n /**\n The id of the snapshot's underlying record\n Example\n ```javascript\n // store.push('post', { id: 1, author: 'Tomster', title: 'Ember.js rocks' });\n postSnapshot.id; // => '1'\n ```\n @property id\n @type {String}\n @public\n */\n this.id = identifier.id;\n\n /**\n A hash of adapter options\n @property adapterOptions\n @type {Object}\n @public\n */\n this.adapterOptions = options.adapterOptions;\n\n /**\n If `include` was passed to the options hash for the request, the value\n would be available here.\n @property include\n @type {String|Array}\n @public\n */\n this.include = options.include;\n\n /**\n The name of the type of the underlying record for this snapshot, as a string.\n @property modelName\n @type {String}\n @public\n */\n this.modelName = internalModel.modelName;\n if (internalModel.hasRecord) {\n this._changedAttributes = recordDataFor(internalModel).changedAttributes();\n }\n }\n\n /**\n The underlying record for this snapshot. Can be used to access methods and\n properties defined on the record.\n Example\n ```javascript\n let json = snapshot.record.toJSON();\n ```\n @property record\n @type {Model}\n @public\n */\n get record() {\n return this._internalModel.getRecord();\n }\n get _attributes() {\n if (this.__attributes !== null) {\n return this.__attributes;\n }\n let record = this.record;\n let attributes = this.__attributes = Object.create(null);\n let attrs = Object.keys(this._store._attributesDefinitionFor(this.identifier));\n attrs.forEach(keyName => {\n if (schemaIsDSModel(this.type)) {\n // if the schema is for a DSModel then the instance is too\n attributes[keyName] = object.get(record, keyName);\n } else {\n attributes[keyName] = recordDataFor(this._internalModel).getAttr(keyName);\n }\n });\n return attributes;\n }\n\n /**\n The type of the underlying record for this snapshot, as a Model.\n @property type\n @public\n @type {Model}\n */\n get type() {\n return this._internalModel.modelClass;\n }\n get isNew() {\n return this._internalModel.isNew();\n }\n\n /**\n Returns the value of an attribute.\n Example\n ```javascript\n // store.push('post', { id: 1, author: 'Tomster', title: 'Ember.js rocks' });\n postSnapshot.attr('author'); // => 'Tomster'\n postSnapshot.attr('title'); // => 'Ember.js rocks'\n ```\n Note: Values are loaded eagerly and cached when the snapshot is created.\n @method attr\n @param {String} keyName\n @return {Object} The attribute value or undefined\n @public\n */\n attr(keyName) {\n if (keyName in this._attributes) {\n return this._attributes[keyName];\n }\n (debug.assert(`Model '${this.identifier}' has no attribute named '${keyName}' defined.`, false));\n }\n\n /**\n Returns all attributes and their corresponding values.\n Example\n ```javascript\n // store.push('post', { id: 1, author: 'Tomster', title: 'Ember.js rocks' });\n postSnapshot.attributes(); // => { author: 'Tomster', title: 'Ember.js rocks' }\n ```\n @method attributes\n @return {Object} All attributes of the current snapshot\n @public\n */\n attributes() {\n return {\n ...this._attributes\n };\n }\n\n /**\n Returns all changed attributes and their old and new values.\n Example\n ```javascript\n // store.push('post', { id: 1, author: 'Tomster', title: 'Ember.js rocks' });\n postModel.set('title', 'Ember.js rocks!');\n postSnapshot.changedAttributes(); // => { title: ['Ember.js rocks', 'Ember.js rocks!'] }\n ```\n @method changedAttributes\n @return {Object} All changed attributes of the current snapshot\n @public\n */\n changedAttributes() {\n let changedAttributes = Object.create(null);\n if (!this._changedAttributes) {\n return changedAttributes;\n }\n let changedAttributeKeys = Object.keys(this._changedAttributes);\n for (let i = 0, length = changedAttributeKeys.length; i < length; i++) {\n let key = changedAttributeKeys[i];\n changedAttributes[key] = this._changedAttributes[key].slice();\n }\n return changedAttributes;\n }\n\n /**\n Returns the current value of a belongsTo relationship.\n `belongsTo` takes an optional hash of options as a second parameter,\n currently supported options are:\n - `id`: set to `true` if you only want the ID of the related record to be\n returned.\n Example\n ```javascript\n // store.push('post', { id: 1, title: 'Hello World' });\n // store.createRecord('comment', { body: 'Lorem ipsum', post: post });\n commentSnapshot.belongsTo('post'); // => Snapshot\n commentSnapshot.belongsTo('post', { id: true }); // => '1'\n // store.push('comment', { id: 1, body: 'Lorem ipsum' });\n commentSnapshot.belongsTo('post'); // => undefined\n ```\n Calling `belongsTo` will return a new Snapshot as long as there's any known\n data for the relationship available, such as an ID. If the relationship is\n known but unset, `belongsTo` will return `null`. If the contents of the\n relationship is unknown `belongsTo` will return `undefined`.\n Note: Relationships are loaded lazily and cached upon first access.\n @method belongsTo\n @param {String} keyName\n @param {Object} [options]\n @public\n @return {(Snapshot|String|null|undefined)} A snapshot or ID of a known\n relationship or null if the relationship is known but unset. undefined\n will be returned if the contents of the relationship is unknown.\n */\n belongsTo(keyName, options) {\n let returnModeIsId = !!(options && options.id);\n let inverseInternalModel;\n let result;\n let store = this._internalModel.store;\n if (returnModeIsId === true && keyName in this._belongsToIds) {\n return this._belongsToIds[keyName];\n }\n if (returnModeIsId === false && keyName in this._belongsToRelationships) {\n return this._belongsToRelationships[keyName];\n }\n let relationshipMeta = store._relationshipMetaFor(this.modelName, null, keyName);\n (!(relationshipMeta && relationshipMeta.kind === 'belongsTo') && debug.assert(`Model '${this.identifier}' has no belongsTo relationship named '${keyName}' defined.`, relationshipMeta && relationshipMeta.kind === 'belongsTo')); // TODO @runspired it seems this code branch would not work with CUSTOM_MODEL_CLASSes\n const graphFor = require('@ember-data/record-data/-private').graphFor;\n const {\n identifier\n } = this;\n const relationship = graphFor(this._store._storeWrapper).get(identifier, keyName);\n (!(relationship) && debug.assert(`You looked up the ${keyName} belongsTo relationship for { type: ${identifier.type}, id: ${identifier.id}, lid: ${identifier.lid} but no such relationship was found.`, relationship));\n (!(relationship.definition.kind === 'belongsTo') && debug.assert(`You looked up the ${keyName} belongsTo relationship for { type: ${identifier.type}, id: ${identifier.id}, lid: ${identifier.lid} but that relationship is a hasMany.`, relationship.definition.kind === 'belongsTo'));\n let value = relationship.getData();\n let data = value && value.data;\n inverseInternalModel = data ? store._internalModelForResource(data) : null;\n if (value && value.data !== undefined) {\n if (inverseInternalModel && !inverseInternalModel.isDeleted()) {\n if (returnModeIsId) {\n result = inverseInternalModel.id;\n } else {\n result = inverseInternalModel.createSnapshot();\n }\n } else {\n result = null;\n }\n }\n if (returnModeIsId) {\n this._belongsToIds[keyName] = result;\n } else {\n this._belongsToRelationships[keyName] = result;\n }\n return result;\n }\n\n /**\n Returns the current value of a hasMany relationship.\n `hasMany` takes an optional hash of options as a second parameter,\n currently supported options are:\n - `ids`: set to `true` if you only want the IDs of the related records to be\n returned.\n Example\n ```javascript\n // store.push('post', { id: 1, title: 'Hello World', comments: [2, 3] });\n postSnapshot.hasMany('comments'); // => [Snapshot, Snapshot]\n postSnapshot.hasMany('comments', { ids: true }); // => ['2', '3']\n // store.push('post', { id: 1, title: 'Hello World' });\n postSnapshot.hasMany('comments'); // => undefined\n ```\n Note: Relationships are loaded lazily and cached upon first access.\n @method hasMany\n @param {String} keyName\n @param {Object} [options]\n @public\n @return {(Array|undefined)} An array of snapshots or IDs of a known\n relationship or an empty array if the relationship is known but unset.\n undefined will be returned if the contents of the relationship is unknown.\n */\n hasMany(keyName, options) {\n let returnModeIsIds = !!(options && options.ids);\n let results;\n let cachedIds = this._hasManyIds[keyName];\n let cachedSnapshots = this._hasManyRelationships[keyName];\n if (returnModeIsIds === true && keyName in this._hasManyIds) {\n return cachedIds;\n }\n if (returnModeIsIds === false && keyName in this._hasManyRelationships) {\n return cachedSnapshots;\n }\n let store = this._internalModel.store;\n let relationshipMeta = store._relationshipMetaFor(this.modelName, null, keyName);\n (!(relationshipMeta && relationshipMeta.kind === 'hasMany') && debug.assert(`Model '${this.identifier}' has no hasMany relationship named '${keyName}' defined.`, relationshipMeta && relationshipMeta.kind === 'hasMany')); // TODO @runspired it seems this code branch would not work with CUSTOM_MODEL_CLASSes\n const graphFor = require('@ember-data/record-data/-private').graphFor;\n const {\n identifier\n } = this;\n const relationship = graphFor(this._store._storeWrapper).get(identifier, keyName);\n (!(relationship) && debug.assert(`You looked up the ${keyName} hasMany relationship for { type: ${identifier.type}, id: ${identifier.id}, lid: ${identifier.lid} but no such relationship was found.`, relationship));\n (!(relationship.definition.kind === 'hasMany') && debug.assert(`You looked up the ${keyName} hasMany relationship for { type: ${identifier.type}, id: ${identifier.id}, lid: ${identifier.lid} but that relationship is a belongsTo.`, relationship.definition.kind === 'hasMany'));\n let value = relationship.getData();\n if (value.data) {\n results = [];\n value.data.forEach(member => {\n let internalModel = store._internalModelForResource(member);\n if (!internalModel.isDeleted()) {\n if (returnModeIsIds) {\n results.push(member.id || null);\n } else {\n results.push(internalModel.createSnapshot());\n }\n }\n });\n }\n\n // we assign even if `undefined` so that we don't reprocess the relationship\n // on next access. This works with the `keyName in` checks above.\n if (returnModeIsIds) {\n this._hasManyIds[keyName] = results;\n } else {\n this._hasManyRelationships[keyName] = results;\n }\n return results;\n }\n\n /**\n Iterates through all the attributes of the model, calling the passed\n function on each attribute.\n Example\n ```javascript\n snapshot.eachAttribute(function(name, meta) {\n // ...\n });\n ```\n @method eachAttribute\n @param {Function} callback the callback to execute\n @param {Object} [binding] the value to which the callback's `this` should be bound\n @public\n */\n eachAttribute(callback, binding) {\n let attrDefs = this._store._attributesDefinitionFor(this.identifier);\n Object.keys(attrDefs).forEach(key => {\n callback.call(binding, key, attrDefs[key]);\n });\n }\n\n /**\n Iterates through all the relationships of the model, calling the passed\n function on each relationship.\n Example\n ```javascript\n snapshot.eachRelationship(function(name, relationship) {\n // ...\n });\n ```\n @method eachRelationship\n @param {Function} callback the callback to execute\n @param {Object} [binding] the value to which the callback's `this` should be bound\n @public\n */\n eachRelationship(callback, binding) {\n let relationshipDefs = this._store._relationshipsDefinitionFor(this.identifier);\n Object.keys(relationshipDefs).forEach(key => {\n callback.call(binding, key, relationshipDefs[key]);\n });\n }\n\n /**\n Serializes the snapshot using the serializer for the model.\n Example\n ```app/adapters/application.js\n import Adapter from '@ember-data/adapter';\n export default Adapter.extend({\n createRecord(store, type, snapshot) {\n let data = snapshot.serialize({ includeId: true });\n let url = `/${type.modelName}`;\n return fetch(url, {\n method: 'POST',\n body: data,\n }).then((response) => response.json())\n }\n });\n ```\n @method serialize\n @param {Object} options\n @return {Object} an object whose values are primitive JSON values only\n @public\n */\n serialize(options) {\n return this._store.serializerFor(this.modelName).serialize(this, options);\n }\n }\n\n /**\n @module @ember-data/store\n */\n\n function _bind(fn, ...args) {\n return function () {\n return fn.apply(undefined, args);\n };\n }\n function _guard(promise, test) {\n let guarded = promise.finally(() => {\n if (!test()) {\n guarded._subscribers.length = 0;\n }\n });\n return guarded;\n }\n function _objectIsAlive(object$1) {\n return !(object.get(object$1, 'isDestroyed') || object.get(object$1, 'isDestroying'));\n }\n function guardDestroyedStore(promise, store, label) {\n let token;\n {\n token = store._trackAsyncRequestStart(label);\n }\n let wrapperPromise = RSVP.resolve(promise, label).then(v => promise);\n return _guard(wrapperPromise, () => {\n {\n store._trackAsyncRequestEnd(token);\n }\n return _objectIsAlive(store);\n });\n }\n\n /**\n This is a helper method that validates a JSON API top-level document\n\n The format of a document is described here:\n http://jsonapi.org/format/#document-top-level\n\n @internal\n */\n function validateDocumentStructure(doc) {\n let errors = [];\n if (!doc || typeof doc !== 'object') {\n errors.push('Top level of a JSON API document must be an object');\n } else {\n if (!('data' in doc) && !('errors' in doc) && !('meta' in doc)) {\n errors.push('One or more of the following keys must be present: \"data\", \"errors\", \"meta\".');\n } else {\n if ('data' in doc && 'errors' in doc) {\n errors.push('Top level keys \"errors\" and \"data\" cannot both be present in a JSON API document');\n }\n }\n if ('data' in doc) {\n if (!(doc.data === null || Array.isArray(doc.data) || typeof doc.data === 'object')) {\n errors.push('data must be null, an object, or an array');\n }\n }\n if ('meta' in doc) {\n if (typeof doc.meta !== 'object') {\n errors.push('meta must be an object');\n }\n }\n if ('errors' in doc) {\n if (!Array.isArray(doc.errors)) {\n errors.push('errors must be an array');\n }\n }\n if ('links' in doc) {\n if (typeof doc.links !== 'object') {\n errors.push('links must be an object');\n }\n }\n if ('jsonapi' in doc) {\n if (typeof doc.jsonapi !== 'object') {\n errors.push('jsonapi must be an object');\n }\n }\n if ('included' in doc) {\n if (typeof doc.included !== 'object') {\n errors.push('included must be an array');\n }\n }\n }\n return errors;\n }\n function normalizeResponseHelper(serializer, store, modelClass, payload, id, requestType) {\n let normalizedResponse = serializer.normalizeResponse(store, modelClass, payload, id, requestType);\n let validationErrors = [];\n {\n validationErrors = validateDocumentStructure(normalizedResponse);\n }\n (!(validationErrors.length === 0) && debug.assert(`normalizeResponse must return a valid JSON API document:\\n\\t* ${validationErrors.join('\\n\\t* ')}`, validationErrors.length === 0));\n return normalizedResponse;\n }\n\n function payloadIsNotBlank$1(adapterPayload) {\n if (Array.isArray(adapterPayload)) {\n return true;\n } else {\n return Object.keys(adapterPayload || {}).length !== 0;\n }\n }\n const SaveOp = Symbol('SaveOp');\n /**\n * Manages the state of network requests initiated by the store\n *\n * @class FetchManager\n * @private\n */\n class FetchManager {\n // saves which are pending in the runloop\n\n // fetches pending in the runloop, waiting to be coalesced\n\n constructor(_store) {\n this._store = _store;\n // used to keep track of all the find requests that need to be coalesced\n this._pendingFetch = new Map();\n this._pendingSave = [];\n this.requestCache = new RequestCache();\n this.isDestroyed = false;\n }\n\n /**\n This method is called by `record.save`, and gets passed a\n resolver for the promise that `record.save` returns.\n It schedules saving to happen at the end of the run loop.\n @internal\n */\n scheduleSave(identifier, options = {}) {\n let promiseLabel = 'DS: Model#save ' + this;\n let resolver = RSVP__default[\"default\"].defer(promiseLabel);\n let query = {\n op: 'saveRecord',\n recordIdentifier: identifier,\n options\n };\n let queryRequest = {\n data: [query]\n };\n let snapshot = new Snapshot(options, identifier, this._store);\n let pendingSaveItem = {\n snapshot: snapshot,\n resolver: resolver,\n identifier,\n options,\n queryRequest\n };\n this._pendingSave.push(pendingSaveItem);\n runloop._backburner.scheduleOnce('actions', this, this._flushPendingSaves);\n this.requestCache.enqueue(resolver.promise, pendingSaveItem.queryRequest);\n return resolver.promise;\n }\n _flushPendingSave(pending) {\n let {\n snapshot,\n resolver,\n identifier,\n options\n } = pending;\n let adapter = this._store.adapterFor(identifier.type);\n let operation = options[SaveOp];\n\n // TODO We have to cast due to our reliance on this private property\n // this will be refactored away once we change our pending API to be identifier based\n let internalModel = snapshot._internalModel;\n let modelName = snapshot.modelName;\n let store = this._store;\n let modelClass = store.modelFor(modelName);\n (!(adapter) && debug.assert(`You tried to update a record but you have no adapter (for ${modelName})`, adapter));\n (!(typeof adapter[operation] === 'function') && debug.assert(`You tried to update a record but your adapter (for ${modelName}) does not implement '${operation}'`, typeof adapter[operation] === 'function'));\n let promise = RSVP.Promise.resolve().then(() => adapter[operation](store, modelClass, snapshot));\n let serializer = store.serializerFor(modelName);\n let label = `DS: Extract and notify about ${operation} completion of ${internalModel}`;\n (!(promise !== undefined) && debug.assert(`Your adapter's '${operation}' method must return a value, but it returned 'undefined'`, promise !== undefined));\n promise = guardDestroyedStore(promise, store, label);\n promise = _guard(promise, _bind(_objectIsAlive, internalModel));\n promise = promise.then(adapterPayload => {\n if (adapterPayload) {\n return normalizeResponseHelper(serializer, store, modelClass, adapterPayload, snapshot.id, operation);\n }\n }, function (error) {\n if (error && error.isAdapterError === true && error.code === 'InvalidError') {\n let parsedErrors = error.errors;\n if (typeof serializer.extractErrors === 'function') {\n parsedErrors = serializer.extractErrors(store, modelClass, error, snapshot.id);\n } else {\n parsedErrors = errorsArrayToHash(error.errors);\n }\n throw {\n error,\n parsedErrors\n };\n } else {\n throw {\n error\n };\n }\n }, label);\n resolver.resolve(promise);\n }\n\n /**\n This method is called at the end of the run loop, and\n flushes any records passed into `scheduleSave`\n @method flushPendingSave\n @internal\n */\n _flushPendingSaves() {\n let pending = this._pendingSave.slice();\n this._pendingSave = [];\n for (let i = 0, j = pending.length; i < j; i++) {\n let pendingItem = pending[i];\n this._flushPendingSave(pendingItem);\n }\n }\n scheduleFetch(identifier, options, shouldTrace) {\n // TODO Probably the store should pass in the query object\n\n let query = {\n op: 'findRecord',\n recordIdentifier: identifier,\n options\n };\n let queryRequest = {\n data: [query]\n };\n let pendingFetches = this._pendingFetch.get(identifier.type);\n\n // We already have a pending fetch for this\n if (pendingFetches) {\n let matchingPendingFetch = pendingFetches.filter(fetch => fetch.identifier.id === identifier.id)[0];\n if (matchingPendingFetch) {\n return matchingPendingFetch.resolver.promise;\n }\n }\n let id = identifier.id;\n let modelName = identifier.type;\n let resolver = RSVP__default[\"default\"].defer(`Fetching ${modelName}' with id: ${id}`);\n let pendingFetchItem = {\n identifier,\n resolver,\n options,\n queryRequest\n };\n {\n if (shouldTrace) {\n let trace;\n try {\n throw new Error(`Trace Origin for scheduled fetch for ${modelName}:${id}.`);\n } catch (e) {\n trace = e;\n }\n\n // enable folks to discover the origin of this findRecord call when\n // debugging. Ideally we would have a tracked queue for requests with\n // labels or local IDs that could be used to merge this trace with\n // the trace made available when we detect an async leak\n pendingFetchItem.trace = trace;\n }\n }\n let promise = resolver.promise;\n if (this._pendingFetch.size === 0) {\n runloop._backburner.schedule('actions', this, this.flushAllPendingFetches);\n }\n let fetches = this._pendingFetch;\n if (!fetches.has(modelName)) {\n fetches.set(modelName, []);\n }\n fetches.get(modelName).push(pendingFetchItem);\n this.requestCache.enqueue(promise, pendingFetchItem.queryRequest);\n return promise;\n }\n _fetchRecord(fetchItem) {\n let identifier = fetchItem.identifier;\n let modelName = identifier.type;\n let adapter = this._store.adapterFor(modelName);\n (!(adapter) && debug.assert(`You tried to find a record but you have no adapter (for ${modelName})`, adapter));\n (!(typeof adapter.findRecord === 'function') && debug.assert(`You tried to find a record but your adapter (for ${modelName}) does not implement 'findRecord'`, typeof adapter.findRecord === 'function'));\n let snapshot = new Snapshot(fetchItem.options, identifier, this._store);\n let klass = this._store.modelFor(identifier.type);\n let promise = RSVP.Promise.resolve().then(() => {\n return adapter.findRecord(this._store, klass, identifier.id, snapshot);\n });\n let id = identifier.id;\n let label = `DS: Handle Adapter#findRecord of '${modelName}' with id: '${id}'`;\n promise = guardDestroyedStore(promise, this._store, label);\n promise = promise.then(adapterPayload => {\n (!(!!payloadIsNotBlank$1(adapterPayload)) && debug.assert(`You made a 'findRecord' request for a '${modelName}' with id '${id}', but the adapter's response did not have any data`, !!payloadIsNotBlank$1(adapterPayload)));\n let serializer = this._store.serializerFor(modelName);\n let payload = normalizeResponseHelper(serializer, this._store, klass, adapterPayload, id, 'findRecord');\n (!(!Array.isArray(payload.data)) && debug.assert(`Ember Data expected the primary data returned from a 'findRecord' response to be an object but instead it found an array.`, !Array.isArray(payload.data)));\n (!('data' in payload && payload.data !== null && typeof payload.data === 'object') && debug.assert(`The 'findRecord' request for ${modelName}:${id} resolved indicating success but contained no primary data. To indicate a 404 not found you should either reject the promise returned by the adapter's findRecord method or throw a NotFoundError.`, 'data' in payload && payload.data !== null && typeof payload.data === 'object'));\n (debug.warn(`You requested a record of type '${modelName}' with id '${id}' but the adapter returned a payload with primary data having an id of '${payload.data.id}'. Use 'store.findRecord()' when the requested id is the same as the one returned by the adapter. In other cases use 'store.queryRecord()' instead.`, coerceId(payload.data.id) === coerceId(id), {\n id: 'ds.store.findRecord.id-mismatch'\n }));\n return payload;\n }, error => {\n throw error;\n }, `DS: Extract payload of '${modelName}'`);\n fetchItem.resolver.resolve(promise);\n }\n\n // TODO should probably refactor expectedSnapshots to be identifiers\n handleFoundRecords(seeking, coalescedPayload, expectedSnapshots) {\n // resolve found records\n let found = Object.create(null);\n let payloads = coalescedPayload.data;\n let coalescedIncluded = coalescedPayload.included || [];\n for (let i = 0, l = payloads.length; i < l; i++) {\n let payload = payloads[i];\n let pair = seeking[payload.id];\n found[payload.id] = payload;\n let included = coalescedIncluded.concat(payloads);\n\n // TODO remove original data from included\n if (pair) {\n let resolver = pair.resolver;\n resolver.resolve({\n data: payload,\n included\n });\n }\n }\n\n // reject missing records\n\n // TODO NOW clean this up to refer to payloads\n let missingSnapshots = [];\n for (let i = 0, l = expectedSnapshots.length; i < l; i++) {\n let snapshot = expectedSnapshots[i];\n assertIsString(snapshot.id);\n\n // We know id is a string because you can't fetch\n // without one.\n if (!found[snapshot.id]) {\n missingSnapshots.push(snapshot);\n }\n }\n if (missingSnapshots.length) {\n (debug.warn('Ember Data expected to find records with the following ids in the adapter response but they were missing: [ \"' + missingSnapshots.map(r => r.id).join('\", \"') + '\" ]', false, {\n id: 'ds.store.missing-records-from-adapter'\n }));\n this.rejectFetchedItems(seeking, missingSnapshots);\n }\n }\n rejectFetchedItems(seeking, snapshots, error) {\n for (let i = 0, l = snapshots.length; i < l; i++) {\n let snapshot = snapshots[i];\n assertIsString(snapshot.id);\n // TODO refactor to identifier.lid to avoid this cast to string\n // we can do this case because you can only fetch an identifier\n // that has an ID\n let pair = seeking[snapshot.id];\n if (pair) {\n pair.resolver.reject(error || new Error(`Expected: '<${snapshot.modelName}:${snapshot.id}>' to be present in the adapter provided payload, but it was not found.`));\n }\n }\n }\n _findMany(adapter, store, modelName, snapshots, identifiers, optionsMap) {\n let modelClass = store.modelFor(modelName); // `adapter.findMany` gets the modelClass still\n let ids = snapshots.map(s => s.id);\n let promise = adapter.findMany(store, modelClass, ids, EmberArray.A(snapshots));\n let label = `DS: Handle Adapter#findMany of '${modelName}'`;\n if (promise === undefined) {\n throw new Error('adapter.findMany returned undefined, this was very likely a mistake');\n }\n promise = guardDestroyedStore(promise, store, label);\n return promise.then(adapterPayload => {\n (!(!!payloadIsNotBlank$1(adapterPayload)) && debug.assert(`You made a 'findMany' request for '${modelName}' records with ids '[${ids}]', but the adapter's response did not have any data`, !!payloadIsNotBlank$1(adapterPayload)));\n let serializer = store.serializerFor(modelName);\n let payload = normalizeResponseHelper(serializer, store, modelClass, adapterPayload, null, 'findMany');\n return payload;\n }, null, `DS: Extract payload of ${modelName}`);\n }\n _processCoalescedGroup(seeking, group, adapter, optionsMap, modelName) {\n //TODO check what happened with identifiers here\n let totalInGroup = group.length;\n let ids = new Array(totalInGroup);\n let groupedSnapshots = new Array(totalInGroup);\n for (let j = 0; j < totalInGroup; j++) {\n groupedSnapshots[j] = group[j];\n ids[j] = groupedSnapshots[j].id;\n }\n let store = this._store;\n if (totalInGroup > 1) {\n this._findMany(adapter, store, modelName, group, groupedSnapshots, optionsMap).then(payloads => {\n this.handleFoundRecords(seeking, payloads, groupedSnapshots);\n }).catch(error => {\n this.rejectFetchedItems(seeking, groupedSnapshots, error);\n });\n } else if (ids.length === 1) {\n let pair = seeking[groupedSnapshots[0].id];\n this._fetchRecord(pair);\n } else {\n (debug.assert(\"You cannot return an empty array from adapter's method groupRecordsForFindMany\", false));\n }\n }\n _flushPendingFetchForType(pendingFetchItems, modelName) {\n let adapter = this._store.adapterFor(modelName);\n let shouldCoalesce = !!adapter.findMany && adapter.coalesceFindRequests;\n let totalItems = pendingFetchItems.length;\n let identifiers = new Array(totalItems);\n let seeking = Object.create(null);\n let optionsMap = new WeakCache$1('fetch-options' );\n for (let i = 0; i < totalItems; i++) {\n let pendingItem = pendingFetchItems[i];\n let identifier = pendingItem.identifier;\n identifiers[i] = identifier;\n optionsMap.set(identifier, pendingItem.options);\n seeking[identifier.id] = pendingItem;\n }\n if (shouldCoalesce) {\n // TODO: Improve records => snapshots => records => snapshots\n //\n // We want to provide records to all store methods and snapshots to all\n // adapter methods. To make sure we're doing that we're providing an array\n // of snapshots to adapter.groupRecordsForFindMany(), which in turn will\n // return grouped snapshots instead of grouped records.\n //\n // But since the _findMany() finder is a store method we need to get the\n // records from the grouped snapshots even though the _findMany() finder\n // will once again convert the records to snapshots for adapter.findMany()\n let snapshots = new Array(totalItems);\n for (let i = 0; i < totalItems; i++) {\n // we know options is in the map due to having just set it above\n // but TS doesn't know so we cast it\n let options = optionsMap.get(identifiers[i]);\n snapshots[i] = new Snapshot(options, identifiers[i], this._store);\n }\n let groups;\n if (adapter.groupRecordsForFindMany) {\n groups = adapter.groupRecordsForFindMany(this, snapshots);\n } else {\n groups = [snapshots];\n }\n for (let i = 0, l = groups.length; i < l; i++) {\n this._processCoalescedGroup(seeking, groups[i], adapter, optionsMap, modelName);\n }\n } else {\n for (let i = 0; i < totalItems; i++) {\n this._fetchRecord(pendingFetchItems[i]);\n }\n }\n }\n getPendingFetch(identifier, options) {\n let pendingRequests = this.requestCache.getPendingRequestsForRecord(identifier).filter(req => {\n return req.type === 'query' && isSameRequest(options, req.request.data[0].options);\n });\n if (pendingRequests.length > 0) {\n return pendingRequests[0][RequestPromise];\n }\n }\n flushAllPendingFetches() {\n if (this.isDestroyed) {\n return;\n }\n this._pendingFetch.forEach(this._flushPendingFetchForType, this);\n this._pendingFetch.clear();\n }\n destroy() {\n this.isDestroyed = true;\n }\n }\n function assertIsString(id) {\n {\n if (typeof id !== 'string') {\n throw new Error(`Cannot fetch record without an id`);\n }\n }\n }\n\n // this function helps resolve whether we have a pending request that we should use instead\n function isSameRequest(options = {}, reqOptions = {}) {\n return options.include === reqOptions.include;\n }\n\n const Cache = new WeakCache$1('subscribers' );\n Cache._generator = () => new Map();\n const Tokens = new WeakCache$1('identifier' );\n\n // 'property' is an internal EmberData only transition period concept.\n\n function unsubscribe(token) {\n let identifier = Tokens.get(token);\n if (!identifier) {\n throw new Error('Passed unknown unsubscribe token to unsubscribe');\n }\n Tokens.delete(token);\n const map = Cache.get(identifier);\n map?.delete(token);\n }\n /*\n Currently only support a single callback per identifier\n */\n class NotificationManager {\n constructor(store) {\n this.store = store;\n }\n subscribe(identifier, callback) {\n let stableIdentifier = this.store.identifierCache.getOrCreateRecordIdentifier(identifier);\n let map = Cache.lookup(stableIdentifier);\n let unsubToken = {};\n map.set(unsubToken, callback);\n Tokens.set(unsubToken, stableIdentifier);\n return unsubToken;\n }\n notify(identifier, value, key) {\n let stableIdentifier = this.store.identifierCache.getOrCreateRecordIdentifier(identifier);\n let callbackMap = Cache.get(stableIdentifier);\n if (!callbackMap || !callbackMap.size) {\n return false;\n }\n callbackMap.forEach(cb => {\n cb(stableIdentifier, value, key);\n });\n return true;\n }\n }\n\n /**\n @module @ember-data/store\n */\n\n /**\n `InternalModelMap` is a custom storage map for internalModels of a given modelName\n used by `IdentityMap`.\n\n It was extracted from an implicit pojo based \"internalModel map\" and preserves\n that interface while we work towards a more official API.\n\n @class InternalModelMap\n @internal\n */\n class InternalModelMap {\n constructor(modelName) {\n this._idToModel = Object.create(null);\n this._models = [];\n this.modelName = modelName;\n }\n get(id) {\n return this._idToModel[id] || null;\n }\n has(id) {\n return !!this._idToModel[id];\n }\n get length() {\n return this._models.length;\n }\n get recordIdentifiers() {\n return this._models.map(m => m.identifier);\n }\n set(id, internalModel) {\n (!(typeof id === 'string' && id.length > 0) && debug.assert(`You cannot index an internalModel by an empty id'`, typeof id === 'string' && id.length > 0));\n (!(internalModel instanceof InternalModel) && debug.assert(`You cannot set an index for an internalModel to something other than an internalModel`, internalModel instanceof InternalModel));\n (!(this.contains(internalModel)) && debug.assert(`You cannot set an index for an internalModel that is not in the InternalModelMap`, this.contains(internalModel)));\n (!(!this.has(id) || this.get(id) === internalModel) && debug.assert(`You cannot update the id index of an InternalModel once set. Attempted to update ${id}.`, !this.has(id) || this.get(id) === internalModel));\n this._idToModel[id] = internalModel;\n }\n add(internalModel, id) {\n (!(!this.contains(internalModel)) && debug.assert(`You cannot re-add an already present InternalModel to the InternalModelMap.`, !this.contains(internalModel)));\n if (id) {\n (!(!this.has(id) || this.get(id) === internalModel) && debug.assert(`Duplicate InternalModel for ${this.modelName}:${id} detected.`, !this.has(id) || this.get(id) === internalModel));\n this._idToModel[id] = internalModel;\n }\n this._models.push(internalModel);\n }\n remove(internalModel, id) {\n delete this._idToModel[id];\n let loc = this._models.indexOf(internalModel);\n if (loc !== -1) {\n this._models.splice(loc, 1);\n }\n }\n contains(internalModel) {\n return this._models.indexOf(internalModel) !== -1;\n }\n\n /**\n An array of all models of this modelName\n @property models\n @internal\n @type Array\n */\n get models() {\n return this._models;\n }\n\n /**\n Destroy all models in the map\n @internal\n */\n clear() {\n let internalModels = this._models;\n this._models = [];\n for (let i = 0; i < internalModels.length; i++) {\n let internalModel = internalModels[i];\n internalModel.unloadRecord();\n }\n }\n }\n\n /**\n @module @ember-data/store\n */\n\n /**\n `IdentityMap` is a custom storage map for records by modelName\n used by `Store`.\n\n @class IdentityMap\n @internal\n */\n class IdentityMap {\n constructor() {\n this._map = Object.create(null);\n }\n /**\n Retrieves the `InternalModelMap` for a given modelName,\n creating one if one did not already exist. This is\n similar to `getWithDefault` or `get` on a `MapWithDefault`\n @method retrieve\n @internal\n @param modelName a previously normalized modelName\n @return {InternalModelMap} the InternalModelMap for the given modelName\n */\n retrieve(modelName) {\n let map = this._map[modelName];\n if (map === undefined) {\n map = this._map[modelName] = new InternalModelMap(modelName);\n }\n return map;\n }\n\n /**\n Clears the contents of all known `RecordMaps`, but does\n not remove the InternalModelMap instances.\n @internal\n */\n clear() {\n let map = this._map;\n let keys = Object.keys(map);\n for (let i = 0; i < keys.length; i++) {\n let key = keys[i];\n map[key].clear();\n }\n }\n }\n\n /**\n @module @ember-data/store\n */\n\n const FactoryCache = new WeakCache$1('internal-model-factory' );\n FactoryCache._generator = store => {\n return new InternalModelFactory(store);\n };\n const RecordCache = new WeakCache$1('identifier' );\n {\n RecordCache._expectMsg = key => `${key} is not a record instantiated by @ember-data/store`;\n }\n function peekRecordIdentifier(record) {\n return RecordCache.get(record);\n }\n\n /**\n Retrieves the unique referentially-stable [RecordIdentifier](/ember-data/release/classes/StableRecordIdentifier)\n assigned to the given record instance.\n\n ```js\n import { recordIdentifierFor } from \"@ember-data/store\";\n\n // ... gain access to a record, for instance with peekRecord or findRecord\n const record = store.peekRecord(\"user\", \"1\");\n\n // get the identifier for the record (see docs for StableRecordIdentifier)\n const identifier = recordIdentifierFor(record);\n\n // access the identifier's properties.\n const { id, type, lid } = identifier;\n ```\n\n @method recordIdentifierFor\n @public\n @static\n @for @ember-data/store\n @param {Object} record a record instance previously obstained from the store.\n @returns {StableRecordIdentifier}\n */\n function recordIdentifierFor(record) {\n return RecordCache.getWithError(record);\n }\n function setRecordIdentifier(record, identifier) {\n if (RecordCache.has(record)) {\n throw new Error(`${record} was already assigned an identifier`);\n }\n\n /*\n It would be nice to do a reverse check here that an identifier has not\n previously been assigned a record; however, unload + rematerialization\n prevents us from having a great way of doing so when CustomRecordClasses\n don't necessarily give us access to a `isDestroyed` for dematerialized\n instance.\n */\n\n RecordCache.set(record, identifier);\n }\n function internalModelFactoryFor(store) {\n return FactoryCache.lookup(store);\n }\n\n /**\n * The InternalModelFactory handles the lifecyle of\n * instantiating, caching, and destroying InternalModel\n * instances.\n *\n * @class InternalModelFactory\n * @internal\n */\n class InternalModelFactory {\n constructor(store) {\n this.store = store;\n this.identifierCache = store.identifierCache;\n this.identifierCache.__configureMerge((identifier, matchedIdentifier, resourceData) => {\n let intendedIdentifier = identifier;\n if (identifier.id !== matchedIdentifier.id) {\n intendedIdentifier = 'id' in resourceData && identifier.id === resourceData.id ? identifier : matchedIdentifier;\n } else if (identifier.type !== matchedIdentifier.type) {\n intendedIdentifier = 'type' in resourceData && identifier.type === resourceData.type ? identifier : matchedIdentifier;\n }\n let altIdentifier = identifier === intendedIdentifier ? matchedIdentifier : identifier;\n\n // check for duplicate InternalModel's\n const map = this.modelMapFor(identifier.type);\n let im = map.get(intendedIdentifier.lid);\n let otherIm = map.get(altIdentifier.lid);\n\n // we cannot merge internalModels when both have records\n // (this may not be strictly true, we could probably swap the internalModel the record points at)\n if (im && otherIm && im.hasRecord && otherIm.hasRecord) {\n if ('id' in resourceData) {\n throw new Error(`Failed to update the 'id' for the RecordIdentifier '${identifier.type}:${identifier.id} (${identifier.lid})' to '${resourceData.id}', because that id is already in use by '${matchedIdentifier.type}:${matchedIdentifier.id} (${matchedIdentifier.lid})'`);\n }\n // TODO @runspired determine when this is even possible\n (debug.assert(`Failed to update the RecordIdentifier '${identifier.type}:${identifier.id} (${identifier.lid})' to merge with the detected duplicate identifier '${matchedIdentifier.type}:${matchedIdentifier.id} (${matchedIdentifier.lid})'`));\n }\n\n // remove otherIm from cache\n if (otherIm) {\n map.remove(otherIm, altIdentifier.lid);\n }\n if (im === null && otherIm === null) {\n // nothing more to do\n return intendedIdentifier;\n\n // only the other has an InternalModel\n // OR only the other has a Record\n } else if (im === null && otherIm !== null || im && !im.hasRecord && otherIm && otherIm.hasRecord) {\n if (im) {\n // TODO check if we are retained in any async relationships\n map.remove(im, intendedIdentifier.lid);\n // im.destroy();\n }\n im = otherIm;\n // TODO do we need to notify the id change?\n im._id = intendedIdentifier.id;\n map.add(im, intendedIdentifier.lid);\n\n // just use im\n } else ;\n\n /*\n TODO @runspired consider adding this to make polymorphism even nicer\n if (HAS_RECORD_DATA_PACKAGE) {\n if (identifier.type !== matchedIdentifier.type) {\n const graphFor = require('@ember-data/record-data/-private').graphFor;\n graphFor(this).registerPolymorphicType(identifier.type, matchedIdentifier.type);\n }\n }\n */\n\n return intendedIdentifier;\n });\n this._identityMap = new IdentityMap();\n }\n\n /**\n * Retrieve the InternalModel for a given { type, id, lid }.\n *\n * If an InternalModel does not exist, it instantiates one.\n *\n * If an InternalModel does exist bus has a scheduled destroy,\n * the scheduled destroy will be cancelled.\n *\n * @method lookup\n * @private\n */\n lookup(resource, data) {\n if (data !== undefined) {\n // if we've been given data associated with this lookup\n // we must first give secondary-caches for LIDs the\n // opportunity to populate based on it\n this.identifierCache.getOrCreateRecordIdentifier(data);\n }\n const identifier = this.identifierCache.getOrCreateRecordIdentifier(resource);\n const internalModel = this.peek(identifier);\n if (internalModel) {\n // unloadRecord is async, if one attempts to unload + then sync push,\n // we must ensure the unload is canceled before continuing\n // The createRecord path will take _existingInternalModelForId()\n // which will call `destroySync` instead for this unload + then\n // sync createRecord scenario. Once we have true client-side\n // delete signaling, we should never call destroySync\n if (internalModel.hasScheduledDestroy()) {\n internalModel.cancelDestroy();\n }\n return internalModel;\n }\n return this._build(identifier, false);\n }\n\n /**\n * Peek the InternalModel for a given { type, id, lid }.\n *\n * If an InternalModel does not exist, return `null`.\n *\n * @method peek\n * @private\n */\n peek(identifier) {\n return this.modelMapFor(identifier.type).get(identifier.lid);\n }\n getByResource(resource) {\n const normalizedResource = constructResource(resource);\n return this.lookup(normalizedResource);\n }\n setRecordId(type, id, lid) {\n const resource = {\n type,\n id: null,\n lid\n };\n const identifier = this.identifierCache.getOrCreateRecordIdentifier(resource);\n const internalModel = this.peek(identifier);\n if (internalModel === null) {\n throw new Error(`Cannot set the id ${id} on the record ${type}:${lid} as there is no such record in the cache.`);\n }\n let oldId = internalModel.id;\n let modelName = internalModel.modelName;\n\n // ID absolutely can't be missing if the oldID is empty (missing Id in response for a new record)\n (!(!(id === null && oldId === null)) && debug.assert(`'${modelName}' was saved to the server, but the response does not have an id and your record does not either.`, !(id === null && oldId === null))); // ID absolutely can't be different than oldID if oldID is not null\n // TODO this assertion and restriction may not strictly be needed in the identifiers world\n (!(!(oldId !== null && id !== oldId)) && debug.assert(`Cannot update the id for '${modelName}:${lid}' from '${oldId}' to '${id}'.`, !(oldId !== null && id !== oldId))); // ID can be null if oldID is not null (altered ID in response for a record)\n // however, this is more than likely a developer error.\n if (oldId !== null && id === null) {\n (debug.warn(`Your ${modelName} record was saved to the server, but the response does not have an id.`, !(oldId !== null && id === null)));\n return;\n }\n let existingInternalModel = this.peekById(modelName, id);\n (!(utils.isNone(existingInternalModel) || existingInternalModel === internalModel) && debug.assert(`'${modelName}' was saved to the server, but the response returned the new id '${id}', which has already been used with another record.'`, utils.isNone(existingInternalModel) || existingInternalModel === internalModel));\n if (identifier.id === null) {\n this.identifierCache.updateRecordIdentifier(identifier, {\n type,\n id\n });\n }\n internalModel.setId(id, true);\n }\n peekById(type, id) {\n const identifier = this.identifierCache.peekRecordIdentifier({\n type,\n id\n });\n let internalModel = identifier ? this.modelMapFor(type).get(identifier.lid) : null;\n if (internalModel && internalModel.hasScheduledDestroy()) {\n // unloadRecord is async, if one attempts to unload + then sync create,\n // we must ensure the unload is complete before starting the create\n // The push path will take this.lookup()\n // which will call `cancelDestroy` instead for this unload + then\n // sync push scenario. Once we have true client-side\n // delete signaling, we should never call destroySync\n internalModel.destroySync();\n internalModel = null;\n }\n return internalModel;\n }\n build(newResourceInfo) {\n return this._build(newResourceInfo, true);\n }\n _build(resource, isCreate = false) {\n if (isCreate === true && resource.id) {\n let existingInternalModel = this.peekById(resource.type, resource.id);\n (!(!existingInternalModel) && debug.assert(`The id ${resource.id} has already been used with another '${resource.type}' record.`, !existingInternalModel));\n }\n const {\n identifierCache\n } = this;\n let identifier;\n if (isCreate === true) {\n identifier = identifierCache.createIdentifierForNewRecord(resource);\n } else {\n identifier = resource;\n }\n\n // lookupFactory should really return an object that creates\n // instances with the injections applied\n let internalModel = new InternalModel(this.store, identifier);\n this.modelMapFor(resource.type).add(internalModel, identifier.lid);\n return internalModel;\n }\n remove(internalModel) {\n let recordMap = this.modelMapFor(internalModel.modelName);\n let clientId = internalModel.identifier.lid;\n recordMap.remove(internalModel, clientId);\n const {\n identifier\n } = internalModel;\n this.identifierCache.forgetRecordIdentifier(identifier);\n }\n modelMapFor(type) {\n return this._identityMap.retrieve(type);\n }\n clear(type) {\n if (type === undefined) {\n this._identityMap.clear();\n } else {\n this.modelMapFor(type).clear();\n }\n }\n }\n\n function _classPrivateFieldLooseBase$3(e, t) { if (!{}.hasOwnProperty.call(e, t)) throw new TypeError(\"attempted to use private field on non-instance\"); return e; }\n var id$3 = 0;\n function _classPrivateFieldLooseKey$3(e) { return \"__private_\" + id$3++ + \"_\" + e; }\n /**\n @module @ember-data/store\n */\n\n function isResourceIdentiferWithRelatedLinks(value) {\n return value && value.links && value.links.related;\n }\n\n /**\n This is the baseClass for the different References\n like RecordReference/HasManyReference/BelongsToReference\n\n @class Reference\n @public\n */\n var _identifier$2 = /*#__PURE__*/_classPrivateFieldLooseKey$3(\"identifier\");\n class Reference {\n constructor(store, identifier) {\n Object.defineProperty(this, _identifier$2, {\n writable: true,\n value: void 0\n });\n this.store = store;\n _classPrivateFieldLooseBase$3(this, _identifier$2)[_identifier$2] = identifier;\n }\n get recordData() {\n return this.store.recordDataFor(_classPrivateFieldLooseBase$3(this, _identifier$2)[_identifier$2], false);\n }\n _resource() {}\n\n /**\n This returns a string that represents how the reference will be\n looked up when it is loaded. If the relationship has a link it will\n use the \"link\" otherwise it defaults to \"id\".\n Example\n ```app/models/post.js\n import Model, { hasMany } from '@ember-data/model';\n export default Model.extend({\n comments: hasMany({ async: true })\n });\n ```\n ```javascript\n let post = store.push({\n data: {\n type: 'post',\n id: 1,\n relationships: {\n comments: {\n data: [{ type: 'comment', id: 1 }]\n }\n }\n }\n });\n let commentsRef = post.hasMany('comments');\n // get the identifier of the reference\n if (commentsRef.remoteType() === \"ids\") {\n let ids = commentsRef.ids();\n } else if (commentsRef.remoteType() === \"link\") {\n let link = commentsRef.link();\n }\n ```\n @method remoteType\n @public\n @return {String} The name of the remote type. This should either be \"link\" or \"ids\"\n */\n remoteType() {\n let value = this._resource();\n if (isResourceIdentiferWithRelatedLinks(value)) {\n return 'link';\n }\n return 'id';\n }\n\n /**\n The link Ember Data will use to fetch or reload this belongs-to\n relationship. By default it uses only the \"related\" resource linkage.\n Example\n ```javascript\n // models/blog.js\n import Model, { belongsTo } from '@ember-data/model';\n export default Model.extend({\n user: belongsTo({ async: true })\n });\n let blog = store.push({\n data: {\n type: 'blog',\n id: 1,\n relationships: {\n user: {\n links: {\n related: '/articles/1/author'\n }\n }\n }\n }\n });\n let userRef = blog.belongsTo('user');\n // get the identifier of the reference\n if (userRef.remoteType() === \"link\") {\n let link = userRef.link();\n }\n ```\n @method link\n @public\n @return {String} The link Ember Data will use to fetch or reload this belongs-to relationship.\n */\n link() {\n let link;\n let resource = this._resource();\n if (isResourceIdentiferWithRelatedLinks(resource)) {\n if (resource.links) {\n link = resource.links.related;\n link = !link || typeof link === 'string' ? link : link.href;\n }\n }\n return link || null;\n }\n links() {\n let resource = this._resource();\n return resource && resource.links ? resource.links : null;\n }\n\n /**\n The meta data for the belongs-to relationship.\n Example\n ```javascript\n // models/blog.js\n import Model, { belongsTo } from '@ember-data/model';\n export default Model.extend({\n user: belongsTo({ async: true })\n });\n let blog = store.push({\n data: {\n type: 'blog',\n id: 1,\n relationships: {\n user: {\n links: {\n related: {\n href: '/articles/1/author'\n },\n },\n meta: {\n lastUpdated: 1458014400000\n }\n }\n }\n }\n });\n let userRef = blog.belongsTo('user');\n userRef.meta() // { lastUpdated: 1458014400000 }\n ```\n @method meta\n @public\n @return {Object} The meta information for the belongs-to relationship.\n */\n meta() {\n let meta = null;\n let resource = this._resource();\n if (resource && resource.meta && typeof resource.meta === 'object') {\n meta = resource.meta;\n }\n return meta;\n }\n }\n\n var _class$2, _descriptor$2, _token$2, _relatedToken;\n function _initializerDefineProperty$2(e, i, r, l) { r && Object.defineProperty(e, i, { enumerable: r.enumerable, configurable: r.configurable, writable: r.writable, value: r.initializer ? r.initializer.call(l) : void 0 }); }\n function _classPrivateFieldLooseBase$2(e, t) { if (!{}.hasOwnProperty.call(e, t)) throw new TypeError(\"attempted to use private field on non-instance\"); return e; }\n var id$2 = 0;\n function _classPrivateFieldLooseKey$2(e) { return \"__private_\" + id$2++ + \"_\" + e; }\n function _applyDecoratedDescriptor$2(i, e, r, n, l) { var a = {}; return Object.keys(n).forEach(function (i) { a[i] = n[i]; }), a.enumerable = !!a.enumerable, a.configurable = !!a.configurable, (\"value\" in a || a.initializer) && (a.writable = !0), a = r.slice().reverse().reduce(function (r, n) { return n(i, e, r) || r; }, a), l && void 0 !== a.initializer && (a.value = a.initializer ? a.initializer.call(l) : void 0, a.initializer = void 0), void 0 === a.initializer ? (Object.defineProperty(i, e, a), null) : a; }\n\n /**\n @module @ember-data/store\n */\n\n /**\n A `BelongsToReference` is a low-level API that allows users and\n addon authors to perform meta-operations on a belongs-to\n relationship.\n\n @class BelongsToReference\n @public\n @extends Reference\n */\n let BelongsToReference = (_class$2 = (_token$2 = /*#__PURE__*/_classPrivateFieldLooseKey$2(\"token\"), _relatedToken = /*#__PURE__*/_classPrivateFieldLooseKey$2(\"relatedToken\"), class BelongsToReference extends Reference {\n constructor(store, parentIdentifier, belongsToRelationship, key) {\n super(store, parentIdentifier);\n // unsubscribe tokens given to us by the notification manager\n Object.defineProperty(this, _token$2, {\n writable: true,\n value: void 0\n });\n Object.defineProperty(this, _relatedToken, {\n writable: true,\n value: null\n });\n _initializerDefineProperty$2(this, \"_ref\", _descriptor$2, this);\n this.key = key;\n this.belongsToRelationship = belongsToRelationship;\n this.type = belongsToRelationship.definition.type;\n const parent = internalModelFactoryFor(store).peek(parentIdentifier);\n this.parent = parent.recordReference;\n this.parentIdentifier = parentIdentifier;\n _classPrivateFieldLooseBase$2(this, _token$2)[_token$2] = store._notificationManager.subscribe(parentIdentifier, (_, bucket, notifiedKey) => {\n if ((bucket === 'relationships' || bucket === 'property') && notifiedKey === key) {\n this._ref++;\n }\n });\n\n // TODO inverse\n }\n destroy() {\n unsubscribe(_classPrivateFieldLooseBase$2(this, _token$2)[_token$2]);\n if (_classPrivateFieldLooseBase$2(this, _relatedToken)[_relatedToken]) {\n unsubscribe(_classPrivateFieldLooseBase$2(this, _relatedToken)[_relatedToken]);\n }\n }\n get _relatedIdentifier() {\n this._ref; // consume the tracked prop\n if (_classPrivateFieldLooseBase$2(this, _relatedToken)[_relatedToken]) {\n unsubscribe(_classPrivateFieldLooseBase$2(this, _relatedToken)[_relatedToken]);\n }\n let resource = this._resource();\n if (resource && resource.data) {\n const identifier = this.store.identifierCache.getOrCreateRecordIdentifier(resource.data);\n _classPrivateFieldLooseBase$2(this, _relatedToken)[_relatedToken] = this.store._notificationManager.subscribe(identifier, (_, bucket, notifiedKey) => {\n if (bucket === 'identity' || (bucket === 'attributes' || bucket === 'property') && notifiedKey === 'id') {\n this._ref++;\n }\n });\n return identifier;\n }\n return null;\n }\n\n /**\n The `id` of the record that this reference refers to. Together, the\n `type()` and `id()` methods form a composite key for the identity\n map. This can be used to access the id of an async relationship\n without triggering a fetch that would normally happen if you\n attempted to use `record.get('relationship.id')`.\n Example\n ```javascript\n // models/blog.js\n import Model, { belongsTo } from '@ember-data/model';\n export default class BlogModel extends Model {\n @belongsTo({ async: true }) user;\n }\n let blog = store.push({\n data: {\n type: 'blog',\n id: 1,\n relationships: {\n user: {\n data: { type: 'user', id: 1 }\n }\n }\n }\n });\n let userRef = blog.belongsTo('user');\n // get the identifier of the reference\n if (userRef.remoteType() === \"id\") {\n let id = userRef.id();\n }\n ```\n @method id\n @public\n @return {String} The id of the record in this belongsTo relationship.\n */\n id() {\n return this._relatedIdentifier?.id || null;\n }\n _resource() {\n return this.recordData.getBelongsTo(this.key);\n }\n\n /**\n `push` can be used to update the data in the relationship and Ember\n Data will treat the new data as the canonical value of this\n relationship on the backend.\n Example\n ```app/models/blog.js\n import Model, { belongsTo } from '@ember-data/model';\n export default class BlogModel extends Model {\n @belongsTo({ async: true }) user;\n }\n let blog = store.push({\n data: {\n type: 'blog',\n id: 1,\n relationships: {\n user: {\n data: { type: 'user', id: 1 }\n }\n }\n }\n });\n let userRef = blog.belongsTo('user');\n // provide data for reference\n userRef.push({\n data: {\n type: 'user',\n id: 1,\n attributes: {\n username: \"@user\"\n }\n }\n }).then(function(user) {\n userRef.value() === user;\n });\n ```\n @method push\n @public\n @param {Object|Promise} objectOrPromise a promise that resolves to a JSONAPI document object describing the new value of this relationship.\n @return {Promise} A promise that resolves with the new value in this belongs-to relationship.\n */\n async push(data) {\n const jsonApiDoc = await RSVP.resolve(data);\n let record = this.store.push(jsonApiDoc);\n Debug.assertPolymorphicType(this.belongsToRelationship.identifier, this.belongsToRelationship.definition, recordIdentifierFor(record), this.store);\n const {\n graph,\n identifier\n } = this.belongsToRelationship;\n this.store._backburner.join(() => {\n graph.push({\n op: 'replaceRelatedRecord',\n record: identifier,\n field: this.key,\n value: recordIdentifierFor(record)\n });\n });\n return record;\n }\n\n /**\n `value()` synchronously returns the current value of the belongs-to\n relationship. Unlike `record.get('relationshipName')`, calling\n `value()` on a reference does not trigger a fetch if the async\n relationship is not yet loaded. If the relationship is not loaded\n it will always return `null`.\n Example\n ```javascript\n // models/blog.js\n import Model, { belongsTo } from '@ember-data/model';\n export default class BlogModel extends Model {\n @belongsTo({ async: true }) user;\n }\n let blog = store.push({\n data: {\n type: 'blog',\n id: 1,\n relationships: {\n user: {\n data: { type: 'user', id: 1 }\n }\n }\n }\n });\n let userRef = blog.belongsTo('user');\n userRef.value(); // null\n // provide data for reference\n userRef.push({\n data: {\n type: 'user',\n id: 1,\n attributes: {\n username: \"@user\"\n }\n }\n }).then(function(user) {\n userRef.value(); // user\n });\n ```\n @method value\n @public\n @return {Model} the record in this relationship\n */\n value() {\n let resource = this._resource();\n if (resource && resource.data) {\n let inverseInternalModel = this.store._internalModelForResource(resource.data);\n if (inverseInternalModel && inverseInternalModel.currentState.isLoaded) {\n return inverseInternalModel.getRecord();\n }\n }\n return null;\n }\n\n /**\n Loads a record in a belongs-to relationship if it is not already\n loaded. If the relationship is already loaded this method does not\n trigger a new load.\n Example\n ```javascript\n // models/blog.js\n import Model, { belongsTo } from '@ember-data/model';\n export default class BlogModel extends Model {\n @belongsTo({ async: true }) user;\n }\n let blog = store.push({\n data: {\n type: 'blog',\n id: 1,\n relationships: {\n user: {\n data: { type: 'user', id: 1 }\n }\n }\n }\n });\n let userRef = blog.belongsTo('user');\n userRef.value(); // null\n userRef.load().then(function(user) {\n userRef.value() === user\n });\n ```\n You may also pass in an options object whose properties will be\n fed forward. This enables you to pass `adapterOptions` into the\n request given to the adapter via the reference.\n Example\n ```javascript\n userRef.load({ adapterOptions: { isPrivate: true } }).then(function(user) {\n userRef.value() === user;\n });\n ```\n ```app/adapters/user.js\n import Adapter from '@ember-data/adapter';\n export default class UserAdapter extends Adapter {\n findRecord(store, type, id, snapshot) {\n // In the adapter you will have access to adapterOptions.\n let adapterOptions = snapshot.adapterOptions;\n }\n });\n ```\n @method load\n @public\n @param {Object} options the options to pass in.\n @return {Promise} a promise that resolves with the record in this belongs-to relationship.\n */\n load(options) {\n let parentInternalModel = internalModelFactoryFor(this.store).peek(this.parentIdentifier);\n return parentInternalModel.getBelongsTo(this.key, options);\n }\n\n /**\n Triggers a reload of the value in this relationship. If the\n remoteType is `\"link\"` Ember Data will use the relationship link to\n reload the relationship. Otherwise it will reload the record by its\n id.\n Example\n ```javascript\n // models/blog.js\n import Model, { belongsTo } from '@ember-data/model';\n export default class BlogModel extends Model {\n @belongsTo({ async: true }) user;\n }\n let blog = store.push({\n data: {\n type: 'blog',\n id: 1,\n relationships: {\n user: {\n data: { type: 'user', id: 1 }\n }\n }\n }\n });\n let userRef = blog.belongsTo('user');\n userRef.reload().then(function(user) {\n userRef.value() === user\n });\n ```\n You may also pass in an options object whose properties will be\n fed forward. This enables you to pass `adapterOptions` into the\n request given to the adapter via the reference. A full example\n can be found in the `load` method.\n Example\n ```javascript\n userRef.reload({ adapterOptions: { isPrivate: true } })\n ```\n @method reload\n @public\n @param {Object} options the options to pass in.\n @return {Promise} a promise that resolves with the record in this belongs-to relationship after the reload has completed.\n */\n reload(options) {\n let parentInternalModel = internalModelFactoryFor(this.store).peek(this.parentIdentifier);\n return parentInternalModel.reloadBelongsTo(this.key, options).then(internalModel => {\n return this.value();\n });\n }\n }), _descriptor$2 = _applyDecoratedDescriptor$2(_class$2.prototype, \"_ref\", [tracking.tracked], {\n configurable: true,\n enumerable: true,\n writable: true,\n initializer: function () {\n return 0;\n }\n }), _applyDecoratedDescriptor$2(_class$2.prototype, \"_relatedIdentifier\", [emberCachedDecoratorPolyfill.cached, compat.dependentKeyCompat], Object.getOwnPropertyDescriptor(_class$2.prototype, \"_relatedIdentifier\"), _class$2.prototype), _class$2);\n\n var _class$1, _descriptor$1, _token$1, _identifier$1, _relatedTokenMap;\n function _initializerDefineProperty$1(e, i, r, l) { r && Object.defineProperty(e, i, { enumerable: r.enumerable, configurable: r.configurable, writable: r.writable, value: r.initializer ? r.initializer.call(l) : void 0 }); }\n function _classPrivateFieldLooseBase$1(e, t) { if (!{}.hasOwnProperty.call(e, t)) throw new TypeError(\"attempted to use private field on non-instance\"); return e; }\n var id$1 = 0;\n function _classPrivateFieldLooseKey$1(e) { return \"__private_\" + id$1++ + \"_\" + e; }\n function _applyDecoratedDescriptor$1(i, e, r, n, l) { var a = {}; return Object.keys(n).forEach(function (i) { a[i] = n[i]; }), a.enumerable = !!a.enumerable, a.configurable = !!a.configurable, (\"value\" in a || a.initializer) && (a.writable = !0), a = r.slice().reverse().reduce(function (r, n) { return n(i, e, r) || r; }, a), l && void 0 !== a.initializer && (a.value = a.initializer ? a.initializer.call(l) : void 0, a.initializer = void 0), void 0 === a.initializer ? (Object.defineProperty(i, e, a), null) : a; }\n /**\n @module @ember-data/store\n */\n\n /**\n A `HasManyReference` is a low-level API that allows users and addon\n authors to perform meta-operations on a has-many relationship.\n\n @class HasManyReference\n @public\n @extends Reference\n */\n let HasManyReference = (_class$1 = (_token$1 = /*#__PURE__*/_classPrivateFieldLooseKey$1(\"token\"), _identifier$1 = /*#__PURE__*/_classPrivateFieldLooseKey$1(\"identifier\"), _relatedTokenMap = /*#__PURE__*/_classPrivateFieldLooseKey$1(\"relatedTokenMap\"), class HasManyReference extends Reference {\n constructor(store, parentIdentifier, hasManyRelationship, key) {\n super(store, parentIdentifier);\n // unsubscribe tokens given to us by the notification manager\n Object.defineProperty(this, _token$1, {\n writable: true,\n value: void 0\n });\n Object.defineProperty(this, _identifier$1, {\n writable: true,\n value: void 0\n });\n Object.defineProperty(this, _relatedTokenMap, {\n writable: true,\n value: void 0\n });\n _initializerDefineProperty$1(this, \"_ref\", _descriptor$1, this);\n this.key = key;\n this.hasManyRelationship = hasManyRelationship;\n this.type = hasManyRelationship.definition.type;\n this.parent = internalModelFactoryFor(store).peek(parentIdentifier).recordReference;\n _classPrivateFieldLooseBase$1(this, _identifier$1)[_identifier$1] = parentIdentifier;\n _classPrivateFieldLooseBase$1(this, _token$1)[_token$1] = store._notificationManager.subscribe(parentIdentifier, (_, bucket, notifiedKey) => {\n if ((bucket === 'relationships' || bucket === 'property') && notifiedKey === key) {\n this._ref++;\n }\n });\n _classPrivateFieldLooseBase$1(this, _relatedTokenMap)[_relatedTokenMap] = new Map();\n // TODO inverse\n }\n destroy() {\n unsubscribe(_classPrivateFieldLooseBase$1(this, _token$1)[_token$1]);\n _classPrivateFieldLooseBase$1(this, _relatedTokenMap)[_relatedTokenMap].forEach(token => {\n unsubscribe(token);\n });\n _classPrivateFieldLooseBase$1(this, _relatedTokenMap)[_relatedTokenMap].clear();\n }\n get _relatedIdentifiers() {\n this._ref; // consume the tracked prop\n\n let resource = this._resource();\n _classPrivateFieldLooseBase$1(this, _relatedTokenMap)[_relatedTokenMap].forEach(token => {\n unsubscribe(token);\n });\n _classPrivateFieldLooseBase$1(this, _relatedTokenMap)[_relatedTokenMap].clear();\n if (resource && resource.data) {\n return resource.data.map(resourceIdentifier => {\n const identifier = this.store.identifierCache.getOrCreateRecordIdentifier(resourceIdentifier);\n const token = this.store._notificationManager.subscribe(identifier, (_, bucket, notifiedKey) => {\n if (bucket === 'identity' || (bucket === 'attributes' || bucket === 'property') && notifiedKey === 'id') {\n this._ref++;\n }\n });\n _classPrivateFieldLooseBase$1(this, _relatedTokenMap)[_relatedTokenMap].set(identifier, token);\n return identifier;\n });\n }\n return [];\n }\n _resource() {\n return this.recordData.getHasMany(this.key);\n }\n\n /**\n This returns a string that represents how the reference will be\n looked up when it is loaded. If the relationship has a link it will\n use the \"link\" otherwise it defaults to \"id\".\n Example\n ```app/models/post.js\n import Model, { hasMany } from '@ember-data/model';\n export default class PostModel extends Model {\n @hasMany({ async: true }) comments;\n }\n ```\n ```javascript\n let post = store.push({\n data: {\n type: 'post',\n id: 1,\n relationships: {\n comments: {\n data: [{ type: 'comment', id: 1 }]\n }\n }\n }\n });\n let commentsRef = post.hasMany('comments');\n // get the identifier of the reference\n if (commentsRef.remoteType() === \"ids\") {\n let ids = commentsRef.ids();\n } else if (commentsRef.remoteType() === \"link\") {\n let link = commentsRef.link();\n }\n ```\n @method remoteType\n @public\n @return {String} The name of the remote type. This should either be `link` or `ids`\n */\n remoteType() {\n let value = this._resource();\n if (value && value.links && value.links.related) {\n return 'link';\n }\n return 'ids';\n }\n\n /**\n `ids()` returns an array of the record IDs in this relationship.\n Example\n ```app/models/post.js\n import Model, { hasMany } from '@ember-data/model';\n export default class PostModel extends Model {\n @hasMany({ async: true }) comments;\n }\n ```\n ```javascript\n let post = store.push({\n data: {\n type: 'post',\n id: 1,\n relationships: {\n comments: {\n data: [{ type: 'comment', id: 1 }]\n }\n }\n }\n });\n let commentsRef = post.hasMany('comments');\n commentsRef.ids(); // ['1']\n ```\n @method ids\n @public\n @return {Array} The ids in this has-many relationship\n */\n ids() {\n return this._relatedIdentifiers.map(identifier => identifier.id);\n }\n\n /**\n `push` can be used to update the data in the relationship and Ember\n Data will treat the new data as the canonical value of this\n relationship on the backend.\n Example\n ```app/models/post.js\n import Model, { hasMany } from '@ember-data/model';\n export default class PostModel extends Model {\n @hasMany({ async: true }) comments;\n }\n ```\n ```\n let post = store.push({\n data: {\n type: 'post',\n id: 1,\n relationships: {\n comments: {\n data: [{ type: 'comment', id: 1 }]\n }\n }\n }\n });\n let commentsRef = post.hasMany('comments');\n commentsRef.ids(); // ['1']\n commentsRef.push([\n [{ type: 'comment', id: 2 }],\n [{ type: 'comment', id: 3 }],\n ])\n commentsRef.ids(); // ['2', '3']\n ```\n @method push\n @public\n @param {Array|Promise} objectOrPromise a promise that resolves to a JSONAPI document object describing the new value of this relationship.\n @return {ManyArray}\n */\n async push(objectOrPromise) {\n const payload = await RSVP.resolve(objectOrPromise);\n let array;\n if (!Array.isArray(payload) && typeof payload === 'object' && Array.isArray(payload.data)) {\n array = payload.data;\n } else {\n array = payload;\n }\n const internalModel = internalModelFactoryFor(this.store).peek(_classPrivateFieldLooseBase$1(this, _identifier$1)[_identifier$1]);\n const {\n store\n } = this;\n let identifiers = array.map(obj => {\n let record;\n if ('data' in obj) {\n // TODO deprecate pushing non-valid JSON:API here\n record = store.push(obj);\n } else {\n record = store.push({\n data: obj\n });\n }\n {\n let relationshipMeta = this.hasManyRelationship.definition;\n let identifier = this.hasManyRelationship.identifier;\n Debug.assertPolymorphicType(identifier, relationshipMeta, recordIdentifierFor(record), store);\n }\n return recordIdentifierFor(record);\n });\n const {\n graph,\n identifier\n } = this.hasManyRelationship;\n store._backburner.join(() => {\n graph.push({\n op: 'replaceRelatedRecords',\n record: identifier,\n field: this.key,\n value: identifiers\n });\n });\n\n // TODO IGOR it seems wrong that we were returning the many array here\n return internalModel.getHasMany(this.key);\n }\n _isLoaded() {\n let hasRelationshipDataProperty = this.hasManyRelationship.state.hasReceivedData;\n if (!hasRelationshipDataProperty) {\n return false;\n }\n let members = this.hasManyRelationship.currentState;\n\n //TODO Igor cleanup\n return members.every(identifier => {\n let internalModel = this.store._internalModelForResource(identifier);\n return internalModel.currentState.isLoaded === true;\n });\n }\n\n /**\n `value()` synchronously returns the current value of the has-many\n relationship. Unlike `record.get('relationshipName')`, calling\n `value()` on a reference does not trigger a fetch if the async\n relationship is not yet loaded. If the relationship is not loaded\n it will always return `null`.\n Example\n ```app/models/post.js\n import Model, { hasMany } from '@ember-data/model';\n export default class PostModel extends Model {\n @hasMany({ async: true }) comments;\n }\n ```\n ```javascript\n let post = store.push({\n data: {\n type: 'post',\n id: 1,\n relationships: {\n comments: {\n data: [{ type: 'comment', id: 1 }]\n }\n }\n }\n });\n let commentsRef = post.hasMany('comments');\n post.get('comments').then(function(comments) {\n commentsRef.value() === comments\n })\n ```\n @method value\n @public\n @return {ManyArray}\n */\n value() {\n const internalModel = internalModelFactoryFor(this.store).peek(_classPrivateFieldLooseBase$1(this, _identifier$1)[_identifier$1]);\n if (this._isLoaded()) {\n return internalModel.getManyArray(this.key);\n }\n return null;\n }\n\n /**\n Loads the relationship if it is not already loaded. If the\n relationship is already loaded this method does not trigger a new\n load. This causes a request to the specified\n relationship link or reloads all items currently in the relationship.\n Example\n ```app/models/post.js\n import Model, { hasMany } from '@ember-data/model';\n export default class PostModel extends Model {\n @hasMany({ async: true }) comments;\n }\n ```\n ```javascript\n let post = store.push({\n data: {\n type: 'post',\n id: 1,\n relationships: {\n comments: {\n data: [{ type: 'comment', id: 1 }]\n }\n }\n }\n });\n let commentsRef = post.hasMany('comments');\n commentsRef.load().then(function(comments) {\n //...\n });\n ```\n You may also pass in an options object whose properties will be\n fed forward. This enables you to pass `adapterOptions` into the\n request given to the adapter via the reference.\n Example\n ```javascript\n commentsRef.load({ adapterOptions: { isPrivate: true } })\n .then(function(comments) {\n //...\n });\n ```\n ```app/adapters/comment.js\n export default ApplicationAdapter.extend({\n findMany(store, type, id, snapshots) {\n // In the adapter you will have access to adapterOptions.\n let adapterOptions = snapshots[0].adapterOptions;\n }\n });\n ```\n @method load\n @public\n @param {Object} options the options to pass in.\n @return {Promise} a promise that resolves with the ManyArray in\n this has-many relationship.\n */\n load(options) {\n const internalModel = internalModelFactoryFor(this.store).peek(_classPrivateFieldLooseBase$1(this, _identifier$1)[_identifier$1]);\n return internalModel.getHasMany(this.key, options);\n }\n\n /**\n Reloads this has-many relationship. This causes a request to the specified\n relationship link or reloads all items currently in the relationship.\n Example\n ```app/models/post.js\n import Model, { hasMany } from '@ember-data/model';\n export default class PostModel extends Model {\n @hasMany({ async: true }) comments;\n }\n ```\n ```javascript\n let post = store.push({\n data: {\n type: 'post',\n id: 1,\n relationships: {\n comments: {\n data: [{ type: 'comment', id: 1 }]\n }\n }\n }\n });\n let commentsRef = post.hasMany('comments');\n commentsRef.reload().then(function(comments) {\n //...\n });\n ```\n You may also pass in an options object whose properties will be\n fed forward. This enables you to pass `adapterOptions` into the\n request given to the adapter via the reference. A full example\n can be found in the `load` method.\n Example\n ```javascript\n commentsRef.reload({ adapterOptions: { isPrivate: true } })\n ```\n @method reload\n @public\n @param {Object} options the options to pass in.\n @return {Promise} a promise that resolves with the ManyArray in this has-many relationship.\n */\n reload(options) {\n const internalModel = internalModelFactoryFor(this.store).peek(_classPrivateFieldLooseBase$1(this, _identifier$1)[_identifier$1]);\n return internalModel.reloadHasMany(this.key, options);\n }\n }), _descriptor$1 = _applyDecoratedDescriptor$1(_class$1.prototype, \"_ref\", [tracking.tracked], {\n configurable: true,\n enumerable: true,\n writable: true,\n initializer: function () {\n return 0;\n }\n }), _applyDecoratedDescriptor$1(_class$1.prototype, \"_relatedIdentifiers\", [emberCachedDecoratorPolyfill.cached, compat.dependentKeyCompat], Object.getOwnPropertyDescriptor(_class$1.prototype, \"_relatedIdentifiers\"), _class$1.prototype), _class$1);\n\n var _class, _descriptor, _token, _identifier;\n function _initializerDefineProperty(e, i, r, l) { r && Object.defineProperty(e, i, { enumerable: r.enumerable, configurable: r.configurable, writable: r.writable, value: r.initializer ? r.initializer.call(l) : void 0 }); }\n function _classPrivateFieldLooseBase(e, t) { if (!{}.hasOwnProperty.call(e, t)) throw new TypeError(\"attempted to use private field on non-instance\"); return e; }\n var id = 0;\n function _classPrivateFieldLooseKey(e) { return \"__private_\" + id++ + \"_\" + e; }\n function _applyDecoratedDescriptor(i, e, r, n, l) { var a = {}; return Object.keys(n).forEach(function (i) { a[i] = n[i]; }), a.enumerable = !!a.enumerable, a.configurable = !!a.configurable, (\"value\" in a || a.initializer) && (a.writable = !0), a = r.slice().reverse().reduce(function (r, n) { return n(i, e, r) || r; }, a), l && void 0 !== a.initializer && (a.value = a.initializer ? a.initializer.call(l) : void 0, a.initializer = void 0), void 0 === a.initializer ? (Object.defineProperty(i, e, a), null) : a; }\n /**\n @module @ember-data/store\n */\n\n /**\n A `RecordReference` is a low-level API that allows users and\n addon authors to perform meta-operations on a record.\n\n @class RecordReference\n @public\n @extends Reference\n */\n let RecordReference = (_class = (_token = /*#__PURE__*/_classPrivateFieldLooseKey(\"token\"), _identifier = /*#__PURE__*/_classPrivateFieldLooseKey(\"identifier\"), class RecordReference extends Reference {\n constructor(store, identifier) {\n super(store, identifier);\n // unsubscribe token given to us by the notification manager\n Object.defineProperty(this, _token, {\n writable: true,\n value: void 0\n });\n Object.defineProperty(this, _identifier, {\n writable: true,\n value: void 0\n });\n _initializerDefineProperty(this, \"_ref\", _descriptor, this);\n this.store = store;\n _classPrivateFieldLooseBase(this, _identifier)[_identifier] = identifier;\n _classPrivateFieldLooseBase(this, _token)[_token] = store._notificationManager.subscribe(identifier, (_, bucket, notifiedKey) => {\n if (bucket === 'identity' || (bucket === 'attributes' || bucket === 'property') && notifiedKey === 'id') {\n this._ref++;\n }\n });\n }\n destroy() {\n unsubscribe(_classPrivateFieldLooseBase(this, _token)[_token]);\n }\n get type() {\n return this.identifier().type;\n }\n get _id() {\n this._ref; // consume the tracked prop\n let identifier = this.identifier();\n if (identifier) {\n return identifier.id;\n }\n return null;\n }\n\n /**\n The `id` of the record that this reference refers to.\n Together, the `type` and `id` properties form a composite key for\n the identity map.\n Example\n ```javascript\n let userRef = store.getReference('user', 1);\n userRef.id(); // '1'\n ```\n @method id\n @public\n @return {String} The id of the record.\n */\n id() {\n return this._id;\n }\n\n /**\n The `identifier` of the record that this reference refers to.\n Together, the `type` and `id` properties form a composite key for\n the identity map.\n Example\n ```javascript\n let userRef = store.getReference('user', 1);\n userRef.identifier(); // '1'\n ```\n @method identifier\n @public\n @return {String} The identifier of the record.\n */\n identifier() {\n return _classPrivateFieldLooseBase(this, _identifier)[_identifier];\n }\n\n /**\n How the reference will be looked up when it is loaded. Currently\n this always returns `identity` to signify that a record will be\n loaded by its `type` and `id`.\n Example\n ```javascript\n const userRef = store.getReference('user', 1);\n userRef.remoteType(); // 'identity'\n ```\n @method remoteType\n @public\n @return {String} 'identity'\n */\n remoteType() {\n return 'identity';\n }\n\n /**\n This API allows you to provide a reference with new data. The\n simplest usage of this API is similar to `store.push`: you provide a\n normalized hash of data and the object represented by the reference\n will update.\n If you pass a promise to `push`, Ember Data will not ask the adapter\n for the data if another attempt to fetch it is made in the\n interim. When the promise resolves, the underlying object is updated\n with the new data, and the promise returned by *this function* is resolved\n with that object.\n For example, `recordReference.push(promise)` will be resolved with a\n record.\n Example\n ```javascript\n let userRef = store.getReference('user', 1);\n // provide data for reference\n userRef.push({\n data: {\n id: \"1\",\n type: \"user\",\n attributes: {\n username: \"@user\"\n }\n }\n }).then(function(user) {\n userRef.value() === user;\n });\n ```\n @method push\n @public\n @param objectOrPromise a JSON:API ResourceDocument or a promise resolving to one\n @return a promise for the value (record or relationship)\n */\n push(objectOrPromise) {\n return RSVP.resolve(objectOrPromise).then(data => {\n return this.store.push(data);\n });\n }\n\n /**\n If the entity referred to by the reference is already loaded, it is\n present as `reference.value`. Otherwise the value returned by this function\n is `null`.\n Example\n ```javascript\n let userRef = store.getReference('user', 1);\n userRef.value(); // user\n ```\n @method value\n @public\n @return {Model} the record for this RecordReference\n */\n value() {\n if (this.id() !== null) {\n let internalModel = internalModelFactoryFor(this.store).peek(_classPrivateFieldLooseBase(this, _identifier)[_identifier]);\n if (internalModel && internalModel.currentState.isLoaded) {\n return internalModel.getRecord();\n }\n }\n return null;\n }\n\n /**\n Triggers a fetch for the backing entity based on its `remoteType`\n (see `remoteType` definitions per reference type).\n Example\n ```javascript\n let userRef = store.getReference('user', 1);\n // load user (via store.find)\n userRef.load().then(...)\n ```\n @method load\n @public\n @return {Promise} the record for this RecordReference\n */\n load() {\n const id = this.id();\n if (id !== null) {\n return this.store.findRecord(this.type, id);\n }\n throw new Error(`Unable to fetch record of type ${this.type} without an id`);\n }\n\n /**\n Reloads the record if it is already loaded. If the record is not\n loaded it will load the record via `store.findRecord`\n Example\n ```javascript\n let userRef = store.getReference('user', 1);\n // or trigger a reload\n userRef.reload().then(...)\n ```\n @method reload\n @public\n @return {Promise} the record for this RecordReference\n */\n reload() {\n const id = this.id();\n if (id !== null) {\n return this.store.findRecord(this.type, id, {\n reload: true\n });\n }\n throw new Error(`Unable to fetch record of type ${this.type} without an id`);\n }\n }), _descriptor = _applyDecoratedDescriptor(_class.prototype, \"_ref\", [tracking.tracked], {\n configurable: true,\n enumerable: true,\n writable: true,\n initializer: function () {\n return 0;\n }\n }), _applyDecoratedDescriptor(_class.prototype, \"_id\", [emberCachedDecoratorPolyfill.cached, compat.dependentKeyCompat], Object.getOwnPropertyDescriptor(_class.prototype, \"_id\"), _class.prototype), _class);\n\n /*\n This file encapsulates the various states that a record can transition\n through during its lifecycle.\n */\n /**\n ### State\n\n Each record has a `currentState` property that explicitly tracks what\n state a record is in at any given time. For instance, if a record is\n newly created and has not yet been sent to the adapter to be saved,\n it would be in the `root.loaded.created.uncommitted` state. If a\n record has had local modifications made to it that are in the\n process of being saved, the record would be in the\n `root.loaded.updated.inFlight` state. (This state path will be\n explained in more detail below.)\n\n Events are sent by the record or its store to the record's\n `currentState` property. How the state reacts to these events is\n dependent on which state it is in. In some states, certain events\n will be invalid and will cause an exception to be raised.\n\n States are hierarchical and every state is a sub-state of the\n `RootState`. For example, a record can be in the\n `root.deleted.uncommitted` state then transitions into the\n `root.deleted.inFlight` state. If a child state does not implement\n an event handler, the state manager will attempt to invoke the event\n on all parent states until the root state is reached. The state\n hierarchy of a record is described in terms of a path string. You\n can determine a record's current state by getting the state's\n `stateName` property:\n\n ```javascript\n record.get('currentState.stateName');\n //=> \"root.created.uncommitted\"\n ```\n\n The hierarchy of valid states that ship with ember data looks like\n this:\n\n ```text\n * root\n * deleted\n * saved\n * uncommitted\n * inFlight\n * empty\n * loaded\n * created\n * uncommitted\n * inFlight\n * saved\n * updated\n * uncommitted\n * inFlight\n * loading\n ```\n\n The `Model` states are themselves stateless. What that means is\n that, the hierarchical states that each of *those* points to is a\n shared data structure. For performance reasons, instead of each\n record getting its own copy of the hierarchy of states, each record\n points to this global, immutable shared instance. How does a state\n know which record it should be acting on? We pass the record\n instance into the state's event handlers as the first argument.\n\n The record passed as the first parameter is where you should stash\n state about the record if needed; you should never store data on the state\n object itself.\n\n ### Events and Flags\n\n A state may implement zero or more events and flags.\n\n #### Events\n\n Events are named functions that are invoked when sent to a record. The\n record will first look for a method with the given name on the\n current state. If no method is found, it will search the current\n state's parent, and then its grandparent, and so on until reaching\n the top of the hierarchy. If the root is reached without an event\n handler being found, an exception will be raised. This can be very\n helpful when debugging new features.\n\n Here's an example implementation of a state with a `myEvent` event handler:\n\n ```javascript\n aState: State.create({\n myEvent: function(manager, param) {\n console.log(\"Received myEvent with\", param);\n }\n })\n ```\n\n To trigger this event:\n\n ```javascript\n record.send('myEvent', 'foo');\n //=> \"Received myEvent with foo\"\n ```\n\n Note that an optional parameter can be sent to a record's `send()` method,\n which will be passed as the second parameter to the event handler.\n\n Events should transition to a different state if appropriate. This can be\n done by calling the record's `transitionTo()` method with a path to the\n desired state. The state manager will attempt to resolve the state path\n relative to the current state. If no state is found at that path, it will\n attempt to resolve it relative to the current state's parent, and then its\n parent, and so on until the root is reached. For example, imagine a hierarchy\n like this:\n\n * created\n * uncommitted <-- currentState\n * inFlight\n * updated\n * inFlight\n\n If we are currently in the `uncommitted` state, calling\n `transitionTo('inFlight')` would transition to the `created.inFlight` state,\n while calling `transitionTo('updated.inFlight')` would transition to\n the `updated.inFlight` state.\n\n Remember that *only events* should ever cause a state transition. You should\n never call `transitionTo()` from outside a state's event handler. If you are\n tempted to do so, create a new event and send that to the state manager.\n\n #### Flags\n\n Flags are Boolean values that can be used to introspect a record's current\n state in a more user-friendly way than examining its state path. For example,\n instead of doing this:\n\n ```javascript\n var statePath = record.get('stateManager.currentPath');\n if (statePath === 'created.inFlight') {\n doSomething();\n }\n ```\n\n You can say:\n\n ```javascript\n if (record.get('isNew') && record.get('isSaving')) {\n doSomething();\n }\n ```\n\n If your state does not set a value for a given flag, the value will\n be inherited from its parent (or the first place in the state hierarchy\n where it is defined).\n\n The current set of flags are defined below. If you want to add a new flag,\n in addition to the area below, you will also need to declare it in the\n `Model` class.\n\n\n * [isEmpty](Model/properties/isEmpty?anchor=isEmpty)\n * [isLoading](Model/properties/isLoading?anchor=isLoading)\n * [isLoaded](Model/properties/isLoaded?anchor=isLoaded)\n * [hasDirtyAttributes](Model/properties/hasDirtyAttributes?anchor=hasDirtyAttributes)\n * [isSaving](Model/properties/isSaving?anchor=isSaving)\n * [isDeleted](Model/properties/isDeleted?anchor=isDeleted)\n * [isNew](Model/properties/isNew?anchor=isNew)\n * [isValid](Model/properties/isValid?anchor=isValid)\n\n @class RootState\n @internal\n */\n\n function didSetProperty(internalModel, context) {\n if (context.isDirty) {\n internalModel.send('becomeDirty');\n } else {\n internalModel.send('propertyWasReset');\n }\n }\n\n // Implementation notes:\n //\n // Each state has a boolean value for all of the following flags:\n //\n // * isLoaded: The record has a populated `data` property. When a\n // record is loaded via `store.find`, `isLoaded` is false\n // until the adapter sets it. When a record is created locally,\n // its `isLoaded` property is always true.\n // * isDirty: The record has local changes that have not yet been\n // saved by the adapter. This includes records that have been\n // created (but not yet saved) or deleted.\n // * isSaving: The record has been committed, but\n // the adapter has not yet acknowledged that the changes have\n // been persisted to the backend.\n // * isDeleted: The record was marked for deletion. When `isDeleted`\n // is true and `isDirty` is true, the record is deleted locally\n // but the deletion was not yet persisted. When `isSaving` is\n // true, the change is in-flight. When both `isDirty` and\n // `isSaving` are false, the change has persisted.\n // * isNew: The record was created on the client and the adapter\n // did not yet report that it was successfully saved.\n // * isValid: The adapter did not report any server-side validation\n // failures.\n\n // The dirty state is a abstract state whose functionality is\n // shared between the `created` and `updated` states.\n //\n // The deleted state shares the `isDirty` flag with the\n // subclasses of `DirtyState`, but with a very different\n // implementation.\n //\n // Dirty states have three child states:\n //\n // `uncommitted`: the store has not yet handed off the record\n // to be saved.\n // `inFlight`: the store has handed off the record to be saved,\n // but the adapter has not yet acknowledged success.\n // `invalid`: the record has invalid information and cannot be\n // sent to the adapter yet.\n const DirtyState = {\n initialState: 'uncommitted',\n // FLAGS\n isDirty: true,\n // SUBSTATES\n\n // When a record first becomes dirty, it is `uncommitted`.\n // This means that there are local pending changes, but they\n // have not yet begun to be saved, and are not invalid.\n uncommitted: {\n // EVENTS\n didSetProperty,\n //TODO(Igor) reloading now triggers a\n //loadingData event, though it seems fine?\n loadingData() {},\n propertyWasReset(internalModel, name) {\n if (!internalModel.hasChangedAttributes()) {\n internalModel.send('rolledBack');\n }\n },\n pushedData(internalModel) {\n if (!internalModel.hasChangedAttributes()) {\n internalModel.transitionTo('loaded.saved');\n }\n },\n becomeDirty() {},\n willCommit(internalModel) {\n internalModel.transitionTo('inFlight');\n },\n reloadRecord(internalModel, {\n resolve,\n options\n }) {\n resolve(internalModel.store._reloadRecord(internalModel, options));\n },\n rolledBack(internalModel) {\n internalModel.transitionTo('loaded.saved');\n internalModel.triggerLater('rolledBack');\n },\n becameInvalid(internalModel) {\n internalModel.transitionTo('invalid');\n },\n rollback(internalModel) {\n internalModel.rollbackAttributes();\n internalModel.triggerLater('ready');\n }\n },\n // Once a record has been handed off to the adapter to be\n // saved, it is in the 'in flight' state. Changes to the\n // record cannot be made during this window.\n inFlight: {\n // FLAGS\n isSaving: true,\n // EVENTS\n didSetProperty,\n becomeDirty() {},\n pushedData() {},\n unloadRecord: assertAgainstUnloadRecord,\n // TODO: More robust semantics around save-while-in-flight\n willCommit() {},\n didCommit(internalModel) {\n internalModel.transitionTo('saved');\n internalModel.send('invokeLifecycleCallbacks', this.dirtyType);\n },\n rolledBack(internalModel) {\n internalModel.triggerLater('rolledBack');\n },\n becameInvalid(internalModel) {\n internalModel.transitionTo('invalid');\n internalModel.send('invokeLifecycleCallbacks');\n },\n becameError(internalModel) {\n internalModel.transitionTo('uncommitted');\n internalModel.triggerLater('becameError', internalModel);\n }\n },\n // A record is in the `invalid` if the adapter has indicated\n // the the record failed server-side invalidations.\n invalid: {\n // FLAGS\n isValid: false,\n // EVENTS\n deleteRecord(internalModel) {\n internalModel.transitionTo('deleted.uncommitted');\n },\n didSetProperty(internalModel, context) {\n internalModel.getRecord().errors._remove(context.name);\n didSetProperty(internalModel, context);\n if (!internalModel.hasErrors()) {\n this.becameValid(internalModel);\n }\n },\n becameInvalid() {},\n becomeDirty() {},\n pushedData() {},\n willCommit(internalModel) {\n clearErrorMessages(internalModel);\n internalModel.transitionTo('inFlight');\n },\n rolledBack(internalModel) {\n clearErrorMessages(internalModel);\n internalModel.transitionTo('loaded.saved');\n internalModel.triggerLater('ready');\n },\n becameValid(internalModel) {\n internalModel.transitionTo('uncommitted');\n },\n invokeLifecycleCallbacks(internalModel) {\n internalModel.triggerLater('becameInvalid', internalModel);\n }\n }\n };\n\n // The created and updated states are created outside the state\n // chart so we can reopen their substates and add mixins as\n // necessary.\n\n function deepClone(object) {\n const clone = {};\n let value;\n for (let prop in object) {\n value = object[prop];\n if (value && typeof value === 'object') {\n clone[prop] = deepClone(value);\n } else {\n clone[prop] = value;\n }\n }\n return clone;\n }\n function mixin(original, hash) {\n for (let prop in hash) {\n original[prop] = hash[prop];\n }\n return original;\n }\n function dirtyState(options) {\n var newState = deepClone(DirtyState);\n return mixin(newState, options);\n }\n const createdState = dirtyState({\n dirtyType: 'created',\n // FLAGS\n isNew: true,\n setup(internalModel) {\n internalModel.store.recordArrayManager.recordDidChange(internalModel.identifier);\n }\n });\n createdState.invalid.rolledBack = function (internalModel) {\n internalModel.transitionTo('deleted.saved');\n internalModel.triggerLater('rolledBack');\n };\n createdState.uncommitted.rolledBack = function (internalModel) {\n internalModel.transitionTo('deleted.saved');\n internalModel.triggerLater('rolledBack');\n };\n const updatedState = dirtyState({\n dirtyType: 'updated'\n });\n function createdStateDeleteRecord(internalModel) {\n internalModel.transitionTo('deleted.saved');\n internalModel.send('invokeLifecycleCallbacks');\n }\n createdState.uncommitted.deleteRecord = createdStateDeleteRecord;\n createdState.invalid.deleteRecord = createdStateDeleteRecord;\n createdState.uncommitted.rollback = function (internalModel) {\n DirtyState.uncommitted.rollback.apply(this, arguments);\n internalModel.transitionTo('deleted.saved');\n };\n createdState.uncommitted.pushedData = function (internalModel) {\n // TODO @runspired consider where to do this once we kill off state machine\n internalModel.store._notificationManager.notify(internalModel.identifier, 'identity');\n internalModel.transitionTo('loaded.updated.uncommitted');\n internalModel.triggerLater('didLoad');\n };\n createdState.uncommitted.propertyWasReset = function () {};\n function assertAgainstUnloadRecord(internalModel) {\n (debug.assert('You can only unload a record which is not inFlight. `' + internalModel + '`', false));\n }\n updatedState.invalid.becameValid = function (internalModel) {\n // we're eagerly transition into the loaded.saved state, even though we could\n // be still dirty; but the setup hook of the loaded.saved state checks for\n // dirty attributes and transitions into the corresponding dirty state\n internalModel.transitionTo('loaded.saved');\n };\n updatedState.inFlight.unloadRecord = assertAgainstUnloadRecord;\n updatedState.uncommitted.deleteRecord = function (internalModel) {\n internalModel.transitionTo('deleted.uncommitted');\n };\n updatedState.invalid.rolledBack = function (internalModel) {\n clearErrorMessages(internalModel);\n internalModel.transitionTo('loaded.saved');\n internalModel.triggerLater('rolledBack');\n };\n const RootState = {\n // FLAGS\n isEmpty: false,\n isLoading: false,\n isLoaded: false,\n isDirty: false,\n isSaving: false,\n isDeleted: false,\n isNew: false,\n isValid: true,\n // DEFAULT EVENTS\n\n // Trying to roll back if you're not in the dirty state\n // doesn't change your state. For example, if you're in the\n // in-flight state, rolling back the record doesn't move\n // you out of the in-flight state.\n rolledBack() {},\n unloadRecord(internalModel) {},\n propertyWasReset() {},\n // SUBSTATES\n\n // A record begins its lifecycle in the `empty` state.\n // If its data will come from the adapter, it will\n // transition into the `loading` state. Otherwise, if\n // the record is being created on the client, it will\n // transition into the `created` state.\n empty: {\n isEmpty: true,\n // EVENTS\n loadingData(internalModel, promise) {\n internalModel.transitionTo('loading');\n },\n loadedData(internalModel) {\n internalModel.transitionTo('loaded.created.uncommitted');\n internalModel.triggerLater('ready');\n },\n pushedData(internalModel) {\n internalModel.transitionTo('loaded.saved');\n internalModel.triggerLater('didLoad');\n internalModel.triggerLater('ready');\n },\n // Record is already in an empty state, triggering transition to empty here\n // produce an error.\n notFound() {}\n },\n // A record enters this state when the store asks\n // the adapter for its data. It remains in this state\n // until the adapter provides the requested data.\n //\n // Usually, this process is asynchronous, using an\n // XHR to retrieve the data.\n loading: {\n // FLAGS\n isLoading: true,\n exit(internalModel) {\n internalModel._promiseProxy = null;\n },\n loadingData() {},\n // EVENTS\n pushedData(internalModel) {\n internalModel.transitionTo('loaded.saved');\n internalModel.triggerLater('didLoad');\n internalModel.triggerLater('ready');\n //TODO this seems out of place here\n internalModel.didCleanError();\n },\n becameError(internalModel) {\n internalModel.triggerLater('becameError', internalModel);\n },\n notFound(internalModel) {\n internalModel.transitionTo('empty');\n }\n },\n // A record enters this state when its data is populated.\n // Most of a record's lifecycle is spent inside substates\n // of the `loaded` state.\n loaded: {\n initialState: 'saved',\n // FLAGS\n isLoaded: true,\n //TODO(Igor) Reloading now triggers a loadingData event,\n //but it should be ok?\n loadingData() {},\n // SUBSTATES\n\n // If there are no local changes to a record, it remains\n // in the `saved` state.\n saved: {\n setup(internalModel) {\n if (internalModel.hasChangedAttributes()) {\n internalModel.adapterDidDirty();\n }\n },\n // EVENTS\n didSetProperty,\n pushedData() {},\n becomeDirty(internalModel) {\n internalModel.transitionTo('updated.uncommitted');\n },\n willCommit(internalModel) {\n internalModel.transitionTo('updated.inFlight');\n },\n reloadRecord() {},\n deleteRecord(internalModel) {\n internalModel.transitionTo('deleted.uncommitted');\n },\n unloadRecord(internalModel) {},\n didCommit() {},\n // loaded.saved.notFound would be triggered by a failed\n // `reload()` on an unchanged record\n notFound() {}\n },\n // A record is in this state after it has been locally\n // created but before the adapter has indicated that\n // it has been saved.\n created: createdState,\n // A record is in this state if it has already been\n // saved to the server, but there are new local changes\n // that have not yet been saved.\n updated: updatedState\n },\n // A record is in this state if it was deleted from the store.\n deleted: {\n initialState: 'uncommitted',\n dirtyType: 'deleted',\n // FLAGS\n isDeleted: true,\n isLoaded: true,\n isDirty: true,\n // TRANSITIONS\n setup(internalModel) {\n internalModel.store.recordArrayManager.recordDidChange(internalModel.identifier);\n },\n // SUBSTATES\n\n // When a record is deleted, it enters the `start`\n // state. It will exit this state when the record\n // starts to commit.\n uncommitted: {\n // EVENTS\n\n willCommit(internalModel) {\n internalModel.transitionTo('inFlight');\n },\n rollback(internalModel) {\n internalModel.rollbackAttributes();\n internalModel.triggerLater('ready');\n },\n pushedData() {},\n becomeDirty() {},\n deleteRecord() {},\n rolledBack(internalModel) {\n internalModel.transitionTo('loaded.saved');\n internalModel.triggerLater('ready');\n internalModel.triggerLater('rolledBack');\n }\n },\n // After a record starts committing, but\n // before the adapter indicates that the deletion\n // has saved to the server, a record is in the\n // `inFlight` substate of `deleted`.\n inFlight: {\n // FLAGS\n isSaving: true,\n // EVENTS\n\n unloadRecord: assertAgainstUnloadRecord,\n // TODO: More robust semantics around save-while-in-flight\n willCommit() {},\n didCommit(internalModel) {\n internalModel.transitionTo('saved');\n internalModel.send('invokeLifecycleCallbacks');\n },\n becameError(internalModel) {\n internalModel.transitionTo('uncommitted');\n internalModel.triggerLater('becameError', internalModel);\n },\n becameInvalid(internalModel) {\n internalModel.transitionTo('invalid');\n internalModel.triggerLater('becameInvalid', internalModel);\n }\n },\n // Once the adapter indicates that the deletion has\n // been saved, the record enters the `saved` substate\n // of `deleted`.\n saved: {\n // FLAGS\n isDirty: false,\n setup(internalModel) {\n internalModel.removeFromInverseRelationships();\n },\n invokeLifecycleCallbacks(internalModel) {\n internalModel.triggerLater('didDelete', internalModel);\n internalModel.triggerLater('didCommit', internalModel);\n },\n willCommit() {},\n didCommit() {},\n pushedData() {}\n },\n invalid: {\n isValid: false,\n didSetProperty(internalModel, context) {\n internalModel.getRecord().errors._remove(context.name);\n didSetProperty(internalModel, context);\n if (!internalModel.hasErrors()) {\n this.becameValid(internalModel);\n }\n },\n becameInvalid() {},\n becomeDirty() {},\n deleteRecord() {},\n willCommit() {},\n rolledBack(internalModel) {\n clearErrorMessages(internalModel);\n internalModel.transitionTo('loaded.saved');\n internalModel.triggerLater('ready');\n },\n becameValid(internalModel) {\n internalModel.transitionTo('uncommitted');\n }\n }\n },\n invokeLifecycleCallbacks(internalModel, dirtyType) {\n if (dirtyType === 'created') {\n internalModel.triggerLater('didCreate', internalModel);\n } else {\n internalModel.triggerLater('didUpdate', internalModel);\n }\n internalModel.triggerLater('didCommit', internalModel);\n }\n };\n function wireState(object, parent, name) {\n // TODO: Use Object.create and copy instead\n object = mixin(parent ? Object.create(parent) : {}, object);\n object.parentState = parent;\n object.stateName = name;\n for (let prop in object) {\n if (!Object.prototype.hasOwnProperty.call(object, prop) || prop === 'parentState' || prop === 'stateName') {\n continue;\n }\n if (typeof object[prop] === 'object') {\n object[prop] = wireState(object[prop], object, name + '.' + prop);\n }\n }\n return object;\n }\n function clearErrorMessages(internalModel) {\n internalModel.getRecord().errors._clear();\n }\n var RootState$1 = wireState(RootState, null, 'root');\n\n // move to TS hacks module that we can delete when this is no longer a necessary recast\n\n /**\n @module @ember-data/store\n */\n\n const {\n hasOwnProperty\n } = Object.prototype;\n let ManyArray;\n let PromiseBelongsTo;\n let _PromiseManyArray; // TODO find a way to get the klass type here\n\n let _found = false;\n let _getModelPackage;\n {\n _getModelPackage = function () {\n if (!_found) {\n let modelPackage = require('@ember-data/model/-private');\n ({\n ManyArray,\n PromiseBelongsTo,\n PromiseManyArray: _PromiseManyArray\n } = modelPackage);\n if (ManyArray && PromiseBelongsTo && _PromiseManyArray) {\n _found = true;\n }\n }\n return _found;\n };\n }\n /*\n The TransitionChainMap caches the `state.enters`, `state.setups`, and final state reached\n when transitioning from one state to another, so that future transitions can replay the\n transition without needing to walk the state tree, collect these hook calls and determine\n the state to transition into.\n\n A future optimization would be to build a single chained method out of the collected enters\n and setups. It may also be faster to do a two level cache (from: { to }) instead of caching based\n on a key that adds the two together.\n */\n const TransitionChainMap = Object.create(null);\n const _extractPivotNameCache = Object.create(null);\n const _splitOnDotCache = Object.create(null);\n function splitOnDot(name) {\n return _splitOnDotCache[name] || (_splitOnDotCache[name] = name.split('.'));\n }\n function extractPivotName(name) {\n return _extractPivotNameCache[name] || (_extractPivotNameCache[name] = splitOnDot(name)[0]);\n }\n class InternalModel {\n // Not typed yet\n\n constructor(store, identifier) {\n this.store = store;\n this.identifier = identifier;\n {\n _getModelPackage();\n }\n this._id = identifier.id;\n this._isUpdatingId = false;\n this.modelName = identifier.type;\n this.clientId = identifier.lid;\n this.__recordData = null;\n this._promiseProxy = null;\n this._isDestroyed = false;\n this._doNotDestroy = false;\n this.isError = false;\n this._pendingRecordArrayManagerFlush = false; // used by the recordArrayManager\n\n // During dematerialization we don't want to rematerialize the record. The\n // reason this might happen is that dematerialization removes records from\n // record arrays, and Ember arrays will always `objectAt(0)` and\n // `objectAt(len - 1)` to test whether or not `firstObject` or `lastObject`\n // have changed.\n this._isDematerializing = false;\n this._scheduledDestroy = null;\n this._record = null;\n this.error = null;\n\n // caches for lazy getters\n this._modelClass = null;\n this.__recordArrays = null;\n this._recordReference = null;\n this.__recordData = null;\n this.error = null;\n\n // other caches\n // class fields have [[DEFINE]] semantics which are significantly slower than [[SET]] semantics here\n this._manyArrayCache = Object.create(null);\n this._relationshipPromisesCache = Object.create(null);\n this._relationshipProxyCache = Object.create(null);\n this.references = Object.create(null);\n this._deferredTriggers = [];\n this.currentState = RootState$1.empty;\n }\n get id() {\n return this.identifier.id;\n }\n set id(value) {\n if (value !== this._id) {\n let newIdentifier = {\n type: this.identifier.type,\n lid: this.identifier.lid,\n id: value\n };\n this.store.identifierCache.updateRecordIdentifier(this.identifier, newIdentifier);\n this.notifyPropertyChange('id');\n }\n }\n get modelClass() {\n if (this.store.modelFor) {\n return this._modelClass || (this._modelClass = this.store.modelFor(this.modelName));\n }\n }\n get recordReference() {\n if (this._recordReference === null) {\n this._recordReference = new RecordReference(this.store, this.identifier);\n }\n return this._recordReference;\n }\n get _recordData() {\n if (this.__recordData === null) {\n let recordData = this.store._createRecordData(this.identifier);\n this.__recordData = recordData;\n return recordData;\n }\n return this.__recordData;\n }\n set _recordData(newValue) {\n this.__recordData = newValue;\n }\n isHiddenFromRecordArrays() {\n // During dematerialization we don't want to rematerialize the record.\n // recordWasDeleted can cause other records to rematerialize because it\n // removes the internal model from the array and Ember arrays will always\n // `objectAt(0)` and `objectAt(len -1)` to check whether `firstObject` or\n // `lastObject` have changed. When this happens we don't want those\n // models to rematerialize their records.\n\n // eager checks to avoid instantiating record data if we are empty or loading\n if (this.currentState.isEmpty) {\n return true;\n }\n if (this.currentState.isLoading) {\n return false;\n }\n let isRecordFullyDeleted = this._isRecordFullyDeleted();\n return this._isDematerializing || this.hasScheduledDestroy() || this.isDestroyed || isRecordFullyDeleted;\n }\n _isRecordFullyDeleted() {\n if (this._recordData.isDeletionCommitted && this._recordData.isDeletionCommitted()) {\n return true;\n } else if (this._recordData.isNew && this._recordData.isDeleted && this._recordData.isNew() && this._recordData.isDeleted()) {\n return true;\n } else {\n return this.currentState.stateName === 'root.deleted.saved';\n }\n }\n isDeleted() {\n if (this._recordData.isDeleted) {\n return this._recordData.isDeleted();\n } else {\n return this.currentState.isDeleted;\n }\n }\n isNew() {\n if (this._recordData.isNew) {\n return this._recordData.isNew();\n } else {\n return this.currentState.isNew;\n }\n }\n getRecord(properties) {\n if (!this._record && !this._isDematerializing) {\n let {\n store\n } = this;\n this._record = store._instantiateRecord(this, this.modelName, this._recordData, this.identifier, properties);\n this._triggerDeferredTriggers();\n }\n return this._record;\n }\n dematerializeRecord() {\n this._isDematerializing = true;\n\n // TODO IGOR add a test that fails when this is missing, something that involves canceling a destroy\n // and the destroy not happening, and then later on trying to destroy\n this._doNotDestroy = false;\n // this has to occur before the internal model is removed\n // for legacy compat.\n if (this._record) {\n this.store.teardownRecord(this._record);\n }\n\n // move to an empty never-loaded state\n // ensure any record notifications happen prior to us\n // unseting the record but after we've triggered\n // destroy\n this.store._backburner.join(() => {\n this._recordData.unloadRecord();\n });\n if (this._record) {\n Object.keys(this._relationshipProxyCache).forEach(key => {\n if (this._relationshipProxyCache[key].destroy) {\n this._relationshipProxyCache[key].destroy();\n }\n delete this._relationshipProxyCache[key];\n });\n }\n this._record = null;\n this.error = null;\n this._previousState = this.currentState;\n this.currentState = RootState$1.empty;\n this.store.recordArrayManager.recordDidChange(this.identifier);\n }\n deleteRecord() {\n runloop.run(() => {\n const backburner = this.store._backburner;\n backburner.run(() => {\n if (this._recordData.setIsDeleted) {\n this._recordData.setIsDeleted(true);\n }\n if (this.isNew()) {\n // destroyRecord follows up deleteRecord with save(). This prevents an unecessary save for a new record\n this._deletedRecordWasNew = true;\n this.send('deleteRecord');\n this._triggerDeferredTriggers();\n this.unloadRecord();\n } else {\n this.send('deleteRecord');\n }\n });\n });\n }\n save(options) {\n if (this._deletedRecordWasNew) {\n return RSVP.Promise.resolve();\n }\n let promiseLabel = 'DS: Model#save ' + this;\n let resolver = RSVP__default[\"default\"].defer(promiseLabel);\n\n // Casting to promise to narrow due to the feature flag paths inside scheduleSave\n return this.store.scheduleSave(this, resolver, options);\n }\n reload(options) {\n if (!options) {\n options = {};\n }\n let internalModel = this;\n return internalModel.store._reloadRecord(internalModel, options).then(function () {\n //TODO NOW seems like we shouldn't need to do this\n return internalModel;\n }, function (error) {\n throw error;\n }, 'DS: Model#reload complete, update flags');\n }\n\n /*\n Unload the record for this internal model. This will cause the record to be\n destroyed and freed up for garbage collection. It will also do a check\n for cleaning up internal models.\n This check is performed by first computing the set of related internal\n models. If all records in this set are unloaded, then the entire set is\n destroyed. Otherwise, nothing in the set is destroyed.\n This means that this internal model will be freed up for garbage collection\n once all models that refer to it via some relationship are also unloaded.\n */\n unloadRecord() {\n if (this.isDestroyed) {\n return;\n }\n this.send('unloadRecord');\n this.dematerializeRecord();\n if (this._scheduledDestroy === null) {\n this._scheduledDestroy = runloop._backburner.schedule('destroy', this, '_checkForOrphanedInternalModels');\n }\n }\n hasScheduledDestroy() {\n return !!this._scheduledDestroy;\n }\n cancelDestroy() {\n (!(!this.isDestroyed) && debug.assert(`You cannot cancel the destruction of an InternalModel once it has already been destroyed`, !this.isDestroyed));\n this._doNotDestroy = true;\n this._isDematerializing = false;\n runloop.cancel(this._scheduledDestroy);\n this._scheduledDestroy = null;\n }\n\n // typically, we prefer to async destroy this lets us batch cleanup work.\n // Unfortunately, some scenarios where that is not possible. Such as:\n //\n // ```js\n // const record = store.findRecord(‘record’, 1);\n // record.unloadRecord();\n // store.createRecord(‘record’, 1);\n // ```\n //\n // In those scenarios, we make that model's cleanup work, sync.\n //\n destroySync() {\n if (this._isDematerializing) {\n this.cancelDestroy();\n }\n this._checkForOrphanedInternalModels();\n if (this.isDestroyed || this.isDestroying) {\n return;\n }\n\n // just in-case we are not one of the orphaned, we should still\n // still destroy ourselves\n this.destroy();\n }\n _checkForOrphanedInternalModels() {\n this._isDematerializing = false;\n this._scheduledDestroy = null;\n if (this.isDestroyed) {\n return;\n }\n }\n _findBelongsTo(key, resource, relationshipMeta, options) {\n // TODO @runspired follow up if parent isNew then we should not be attempting load here\n return this.store._findBelongsToByJsonApiResource(resource, this, relationshipMeta, options).then(internalModel => handleCompletedRelationshipRequest(this, key, resource._relationship, internalModel, null), e => handleCompletedRelationshipRequest(this, key, resource._relationship, null, e));\n }\n getBelongsTo(key, options) {\n let resource = this._recordData.getBelongsTo(key);\n let identifier = resource && resource.data ? this.store.identifierCache.getOrCreateRecordIdentifier(resource.data) : null;\n let relationshipMeta = this.store._relationshipMetaFor(this.modelName, null, key);\n if (!relationshipMeta) return;\n let store = this.store;\n let parentInternalModel = this;\n let async = relationshipMeta.options.async;\n let isAsync = typeof async === 'undefined' ? true : async;\n let _belongsToState = {\n key,\n store,\n originatingInternalModel: this,\n modelName: relationshipMeta.type\n };\n if (isAsync) {\n let internalModel = identifier !== null ? store._internalModelForResource(identifier) : null;\n if (resource._relationship.state.hasFailedLoadAttempt) {\n return this._relationshipProxyCache[key];\n }\n let promise = this._findBelongsTo(key, resource, relationshipMeta, options);\n return this._updatePromiseProxyFor('belongsTo', key, {\n promise,\n content: internalModel ? internalModel.getRecord() : null,\n _belongsToState\n });\n } else {\n if (identifier === null) {\n return null;\n } else {\n let internalModel = store._internalModelForResource(identifier);\n let toReturn = internalModel.getRecord();\n (!(toReturn === null || !toReturn.isEmpty) && debug.assert(\"You looked up the '\" + key + \"' relationship on a '\" + parentInternalModel.modelName + \"' with id \" + parentInternalModel.id + ' but some of the associated records were not loaded. Either make sure they are all loaded together with the parent record, or specify that the relationship is async (`belongsTo({ async: true })`)', toReturn === null || !toReturn.isEmpty));\n return toReturn;\n }\n }\n }\n getManyArray(key, definition) {\n {\n let manyArray = this._manyArrayCache[key];\n if (!definition) {\n const graphFor = require('@ember-data/record-data/-private').graphFor;\n definition = graphFor(this.store).get(this.identifier, key).definition;\n }\n if (!manyArray) {\n manyArray = ManyArray.create({\n store: this.store,\n type: this.store.modelFor(definition.type),\n recordData: this._recordData,\n key,\n isPolymorphic: definition.isPolymorphic,\n isAsync: definition.isAsync,\n _inverseIsAsync: definition.inverseIsAsync,\n internalModel: this,\n isLoaded: !definition.isAsync\n });\n this._manyArrayCache[key] = manyArray;\n }\n return manyArray;\n }\n }\n fetchAsyncHasMany(key, relationship, manyArray, options) {\n {\n let loadingPromise = this._relationshipPromisesCache[key];\n if (loadingPromise) {\n return loadingPromise;\n }\n const jsonApi = this._recordData.getHasMany(key);\n loadingPromise = this.store._findHasManyByJsonApiResource(jsonApi, this, relationship, options).then(() => handleCompletedRelationshipRequest(this, key, relationship, manyArray, null), e => handleCompletedRelationshipRequest(this, key, relationship, manyArray, e));\n this._relationshipPromisesCache[key] = loadingPromise;\n return loadingPromise;\n }\n }\n getHasMany(key, options) {\n {\n const graphFor = require('@ember-data/record-data/-private').graphFor;\n const relationship = graphFor(this.store).get(this.identifier, key);\n const {\n definition,\n state\n } = relationship;\n let manyArray = this.getManyArray(key, definition);\n if (definition.isAsync) {\n if (state.hasFailedLoadAttempt) {\n return this._relationshipProxyCache[key];\n }\n let promise = this.fetchAsyncHasMany(key, relationship, manyArray, options);\n return this._updatePromiseProxyFor('hasMany', key, {\n promise,\n content: manyArray\n });\n } else {\n (!(!anyUnloaded(this.store, relationship)) && debug.assert(`You looked up the '${key}' relationship on a '${this.modelName}' with id ${this.id} but some of the associated records were not loaded. Either make sure they are all loaded together with the parent record, or specify that the relationship is async ('hasMany({ async: true })')`, !anyUnloaded(this.store, relationship)));\n return manyArray;\n }\n }\n }\n _updatePromiseProxyFor(kind, key, args) {\n let promiseProxy = this._relationshipProxyCache[key];\n if (kind === 'hasMany') {\n if (promiseProxy) {\n promiseProxy._update(args.promise, args.content);\n } else {\n promiseProxy = this._relationshipProxyCache[key] = new _PromiseManyArray(args.promise, args.content);\n }\n return promiseProxy;\n }\n if (promiseProxy) {\n if (args.content !== undefined) {\n // this usage of `any` can be removed when `@types/ember_object` proxy allows `null` for content\n promiseProxy.set('content', args.content);\n }\n promiseProxy.set('promise', args.promise);\n } else {\n const klass = PromiseBelongsTo;\n // this usage of `any` can be removed when `@types/ember_object` proxy allows `null` for content\n this._relationshipProxyCache[key] = klass.create(args);\n }\n return this._relationshipProxyCache[key];\n }\n reloadHasMany(key, options) {\n {\n let loadingPromise = this._relationshipPromisesCache[key];\n if (loadingPromise) {\n return loadingPromise;\n }\n const graphFor = require('@ember-data/record-data/-private').graphFor;\n const relationship = graphFor(this.store).get(this.identifier, key);\n const {\n definition,\n state\n } = relationship;\n state.hasFailedLoadAttempt = false;\n state.shouldForceReload = true;\n let manyArray = this.getManyArray(key, definition);\n let promise = this.fetchAsyncHasMany(key, relationship, manyArray, options);\n if (this._relationshipProxyCache[key]) {\n return this._updatePromiseProxyFor('hasMany', key, {\n promise\n });\n }\n return promise;\n }\n }\n reloadBelongsTo(key, options) {\n let loadingPromise = this._relationshipPromisesCache[key];\n if (loadingPromise) {\n return loadingPromise;\n }\n let resource = this._recordData.getBelongsTo(key);\n // TODO move this to a public api\n if (resource._relationship) {\n resource._relationship.state.hasFailedLoadAttempt = false;\n resource._relationship.state.shouldForceReload = true;\n }\n let relationshipMeta = this.store._relationshipMetaFor(this.modelName, null, key);\n let promise = this._findBelongsTo(key, resource, relationshipMeta, options);\n if (this._relationshipProxyCache[key]) {\n return this._updatePromiseProxyFor('belongsTo', key, {\n promise\n });\n }\n return promise;\n }\n destroyFromRecordData() {\n if (this._doNotDestroy) {\n this._doNotDestroy = false;\n return;\n }\n this.destroy();\n }\n destroy() {\n (!(!this._record || this._record.get('isDestroyed') || this._record.get('isDestroying')) && debug.assert('Cannot destroy an internalModel while its record is materialized', !this._record || this._record.get('isDestroyed') || this._record.get('isDestroying')));\n this.isDestroying = true;\n if (this._recordReference) {\n this._recordReference.destroy();\n }\n this._recordReference = null;\n let cache = this._manyArrayCache;\n Object.keys(cache).forEach(key => {\n cache[key].destroy();\n delete cache[key];\n });\n if (this.references) {\n cache = this.references;\n Object.keys(cache).forEach(key => {\n cache[key].destroy();\n delete cache[key];\n });\n }\n internalModelFactoryFor(this.store).remove(this);\n this._isDestroyed = true;\n }\n setupData(data) {\n let changedKeys = this._recordData.pushData(data, this.hasRecord);\n if (this.hasRecord) {\n // TODO @runspired should this be going through the notification manager?\n this._record._notifyProperties(changedKeys);\n }\n this.send('pushedData');\n }\n setDirtyHasMany(key, records) {\n assertRecordsPassedToHasMany(records);\n return this._recordData.setDirtyHasMany(key, extractRecordDatasFromRecords(records));\n }\n setDirtyBelongsTo(key, value) {\n return this._recordData.setDirtyBelongsTo(key, extractRecordDataFromRecord(value));\n }\n setDirtyAttribute(key, value) {\n if (this.isDeleted()) {\n {\n throw new EmberError__default[\"default\"](`Attempted to set '${key}' to '${value}' on the deleted record ${this}`);\n }\n }\n let currentValue = this._recordData.getAttr(key);\n if (currentValue !== value) {\n this._recordData.setDirtyAttribute(key, value);\n let isDirty = this._recordData.isAttrDirty(key);\n this.send('didSetProperty', {\n name: key,\n isDirty: isDirty\n });\n }\n return value;\n }\n get isDestroyed() {\n return this._isDestroyed;\n }\n get hasRecord() {\n return !!this._record;\n }\n createSnapshot(options = {}) {\n return new Snapshot(options, this.identifier, this.store);\n }\n hasChangedAttributes() {\n if (!this.__recordData) {\n // no need to calculate changed attributes when calling `findRecord`\n return false;\n }\n return this._recordData.hasChangedAttributes();\n }\n changedAttributes() {\n if (!this.__recordData) {\n // no need to calculate changed attributes when calling `findRecord`\n return {};\n }\n return this._recordData.changedAttributes();\n }\n adapterWillCommit() {\n this._recordData.willCommit();\n this.send('willCommit');\n }\n adapterDidDirty() {\n this.send('becomeDirty');\n }\n send(name, context) {\n let currentState = this.currentState;\n if (!currentState[name]) {\n this._unhandledEvent(currentState, name, context);\n }\n return currentState[name](this, context);\n }\n notifyHasManyChange(key) {\n if (this.hasRecord) {\n let manyArray = this._manyArrayCache[key];\n let hasPromise = !!this._relationshipPromisesCache[key];\n if (manyArray && hasPromise) {\n // do nothing, we will notify the ManyArray directly\n // once the fetch has completed.\n return;\n }\n this.store._notificationManager.notify(this.identifier, 'relationships', key);\n }\n }\n notifyBelongsToChange(key) {\n if (this.hasRecord) {\n this.store._notificationManager.notify(this.identifier, 'relationships', key);\n }\n }\n notifyPropertyChange(key) {\n if (this.hasRecord) {\n // TODO this should likely *mostly* be the `attributes` bucket\n // but it seems for local mutations we rely on computed updating\n // iteself when set. As we design our own thing we may need to change\n // that.\n this.store._notificationManager.notify(this.identifier, 'property', key);\n }\n }\n notifyStateChange(key) {\n if (this.hasRecord) {\n this.store._notificationManager.notify(this.identifier, 'state');\n }\n if (!key || key === 'isDeletionCommitted') {\n this.store.recordArrayManager.recordDidChange(this.identifier);\n }\n }\n didCreateRecord() {\n this._recordData.clientDidCreate();\n }\n rollbackAttributes() {\n this.store._backburner.join(() => {\n let dirtyKeys = this._recordData.rollbackAttributes();\n if (object.get(this, 'isError')) {\n this.didCleanError();\n }\n this.send('rolledBack');\n if (this._record && dirtyKeys && dirtyKeys.length > 0) {\n this._record._notifyProperties(dirtyKeys);\n }\n });\n }\n transitionTo(name) {\n // POSSIBLE TODO: Remove this code and replace with\n // always having direct reference to state objects\n\n let pivotName = extractPivotName(name);\n let state = this.currentState;\n let transitionMapId = `${state.stateName}->${name}`;\n do {\n if (state.exit) {\n state.exit(this);\n }\n state = state.parentState;\n } while (!state[pivotName]);\n let setups;\n let enters;\n let i;\n let l;\n let map = TransitionChainMap[transitionMapId];\n if (map) {\n setups = map.setups;\n enters = map.enters;\n state = map.state;\n } else {\n setups = [];\n enters = [];\n let path = splitOnDot(name);\n for (i = 0, l = path.length; i < l; i++) {\n state = state[path[i]];\n if (state.enter) {\n enters.push(state);\n }\n if (state.setup) {\n setups.push(state);\n }\n }\n TransitionChainMap[transitionMapId] = {\n setups,\n enters,\n state\n };\n }\n for (i = 0, l = enters.length; i < l; i++) {\n enters[i].enter(this);\n }\n this.currentState = state;\n if (this.hasRecord && typeof this._record.notifyPropertyChange === 'function') {\n // TODO refactor Model to have all flags pull from the notification manager\n // and for currentState.stateName to be constructed from flag state.\n // Probably just port this work from ember-m3\n // After that we can eliminate this.\n this.notifyStateChange('currentState');\n // this._record.notifyPropertyChange('currentState');\n }\n for (i = 0, l = setups.length; i < l; i++) {\n setups[i].setup(this);\n }\n }\n _unhandledEvent(state, name, context) {\n let errorMessage = 'Attempted to handle event `' + name + '` ';\n errorMessage += 'on ' + String(this) + ' while in state ';\n errorMessage += state.stateName + '. ';\n if (context !== undefined) {\n errorMessage += 'Called with ' + debug.inspect(context) + '.';\n }\n throw new EmberError__default[\"default\"](errorMessage);\n }\n triggerLater(...args) {\n if (this._deferredTriggers.push(args) !== 1) {\n return;\n }\n this.store._updateInternalModel(this);\n }\n _triggerDeferredTriggers() {\n //TODO: Before 1.0 we want to remove all the events that happen on the pre materialized record,\n //but for now, we queue up all the events triggered before the record was materialized, and flush\n //them once we have the record\n if (!this.hasRecord) {\n return;\n }\n let triggers = this._deferredTriggers;\n let record = this._record;\n let trigger = record.trigger;\n // TODO Igor make nicer check\n if (trigger && typeof trigger === 'function') {\n for (let i = 0, l = triggers.length; i < l; i++) {\n let eventName = triggers[i];\n trigger.apply(record, eventName);\n }\n }\n triggers.length = 0;\n }\n removeFromInverseRelationships() {\n if (this.__recordData) {\n this.store._backburner.join(() => {\n this._recordData.removeFromInverseRelationships();\n });\n }\n }\n\n /*\n When a find request is triggered on the store, the user can optionally pass in\n attributes and relationships to be preloaded. These are meant to behave as if they\n came back from the server, except the user obtained them out of band and is informing\n the store of their existence. The most common use case is for supporting client side\n nested URLs, such as `/posts/1/comments/2` so the user can do\n `store.findRecord('comment', 2, { preload: { post: 1 } })` without having to fetch the post.\n Preloaded data can be attributes and relationships passed in either as IDs or as actual\n models.\n */\n preloadData(preload) {\n let jsonPayload = {};\n //TODO(Igor) consider the polymorphic case\n Object.keys(preload).forEach(key => {\n let preloadValue = object.get(preload, key);\n let relationshipMeta = this.modelClass.metaForProperty(key);\n if (relationshipMeta.isRelationship) {\n if (!jsonPayload.relationships) {\n jsonPayload.relationships = {};\n }\n jsonPayload.relationships[key] = this._preloadRelationship(key, preloadValue);\n } else {\n if (!jsonPayload.attributes) {\n jsonPayload.attributes = {};\n }\n jsonPayload.attributes[key] = preloadValue;\n }\n });\n this._recordData.pushData(jsonPayload);\n }\n _preloadRelationship(key, preloadValue) {\n let relationshipMeta = this.modelClass.metaForProperty(key);\n let modelClass = relationshipMeta.type;\n let data;\n if (relationshipMeta.kind === 'hasMany') {\n (!(Array.isArray(preloadValue)) && debug.assert('You need to pass in an array to set a hasMany property on a record', Array.isArray(preloadValue)));\n data = preloadValue.map(value => this._convertPreloadRelationshipToJSON(value, modelClass));\n } else {\n data = this._convertPreloadRelationshipToJSON(preloadValue, modelClass);\n }\n return {\n data\n };\n }\n _convertPreloadRelationshipToJSON(value, modelClass) {\n if (typeof value === 'string' || typeof value === 'number') {\n return {\n type: modelClass,\n id: value\n };\n }\n let internalModel;\n if (value._internalModel) {\n internalModel = value._internalModel;\n } else {\n internalModel = value;\n }\n // TODO IGOR DAVID assert if no id is present\n return {\n type: internalModel.modelName,\n id: internalModel.id\n };\n }\n\n /*\n * calling `store.setRecordId` is necessary to update\n * the cache index for this record if we have changed.\n *\n * However, since the store is not aware of whether the update\n * is from us (via user set) or from a push of new data\n * it will also call us so that we can notify and update state.\n *\n * When it does so it calls with `fromCache` so that we can\n * short-circuit instead of cycling back.\n *\n * This differs from the short-circuit in the `_isUpdatingId`\n * case in that the the cache can originate the call to setId,\n * so on first entry we will still need to do our own update.\n */\n setId(id, fromCache = false) {\n if (this._isUpdatingId === true) {\n return;\n }\n this._isUpdatingId = true;\n let didChange = id !== this._id;\n this._id = id;\n if (didChange && id !== null) {\n if (!fromCache) {\n this.store.setRecordId(this.modelName, id, this.clientId);\n }\n // internal set of ID to get it to RecordData from DS.Model\n // if we are within create we may not have a recordData yet.\n if (this.__recordData && this._recordData.__setId) {\n this._recordData.__setId(id);\n }\n }\n if (didChange && this.hasRecord) {\n this.store._notificationManager.notify(this.identifier, 'identity');\n }\n this._isUpdatingId = false;\n }\n didError() {}\n didCleanError() {}\n\n /*\n If the adapter did not return a hash in response to a commit,\n merge the changed attributes and relationships into the existing\n saved data.\n */\n adapterDidCommit(data) {\n this.didCleanError();\n this._recordData.didCommit(data);\n this.send('didCommit');\n this.store.recordArrayManager.recordDidChange(this.identifier);\n if (!data) {\n return;\n }\n this.store._notificationManager.notify(this.identifier, 'attributes');\n }\n hasErrors() {\n if (this._recordData.getErrors) {\n return this._recordData.getErrors(this.identifier).length > 0;\n } else {\n let errors = this.getRecord().errors;\n return errors.length > 0;\n }\n }\n\n // FOR USE DURING COMMIT PROCESS\n adapterDidInvalidate(parsedErrors, error) {\n // TODO @runspired this should be handled by RecordState\n // and errors should be dirtied but lazily fetch if at\n // all possible. We should only notify errors here.\n let attribute;\n if (error && parsedErrors) {\n if (!this._recordData.getErrors) {\n for (attribute in parsedErrors) {\n if (hasOwnProperty.call(parsedErrors, attribute)) {\n this.getRecord().errors._add(attribute, parsedErrors[attribute]);\n }\n }\n }\n let jsonApiErrors = errorsHashToArray(parsedErrors);\n this.send('becameInvalid');\n if (jsonApiErrors.length === 0) {\n jsonApiErrors = [{\n title: 'Invalid Error',\n detail: '',\n source: {\n pointer: '/data'\n }\n }];\n }\n this._recordData.commitWasRejected(this.identifier, jsonApiErrors);\n } else {\n this.send('becameError');\n this._recordData.commitWasRejected(this.identifier);\n }\n }\n notifyErrorsChange() {\n this.store._notificationManager.notify(this.identifier, 'errors');\n }\n adapterDidError() {\n this.send('becameError');\n this._recordData.commitWasRejected();\n }\n toString() {\n return `<${this.modelName}:${this.id}>`;\n }\n referenceFor(kind, name) {\n let reference = this.references[name];\n if (!reference) {\n const graphFor = require('@ember-data/record-data/-private').graphFor;\n const relationship = graphFor(this.store._storeWrapper).get(this.identifier, name);\n if (kind) {\n let modelName = this.modelName;\n let actualRelationshipKind = relationship.definition.kind;\n (!(actualRelationshipKind === kind) && debug.assert(`You tried to get the '${name}' relationship on a '${modelName}' via record.${kind}('${name}'), but the relationship is of kind '${actualRelationshipKind}'. Use record.${actualRelationshipKind}('${name}') instead.`, actualRelationshipKind === kind));\n }\n let relationshipKind = relationship.definition.kind;\n let identifierOrInternalModel = this.identifier;\n if (relationshipKind === 'belongsTo') {\n reference = new BelongsToReference(this.store, identifierOrInternalModel, relationship, name);\n } else if (relationshipKind === 'hasMany') {\n reference = new HasManyReference(this.store, identifierOrInternalModel, relationship, name);\n }\n this.references[name] = reference;\n }\n return reference;\n }\n }\n function handleCompletedRelationshipRequest(internalModel, key, relationship, value, error) {\n delete internalModel._relationshipPromisesCache[key];\n relationship.state.shouldForceReload = false;\n const isHasMany = relationship.definition.kind === 'hasMany';\n if (isHasMany) {\n // we don't notify the record property here to avoid refetch\n // only the many array\n value.notify();\n }\n if (error) {\n relationship.state.hasFailedLoadAttempt = true;\n let proxy = internalModel._relationshipProxyCache[key];\n // belongsTo relationships are sometimes unloaded\n // when a load fails, in this case we need\n // to make sure that we aren't proxying\n // to destroyed content\n // for the sync belongsTo reload case there will be no proxy\n // for the async reload case there will be no proxy if the ui\n // has never been accessed\n if (proxy && !isHasMany) {\n if (proxy.content && proxy.content.isDestroying) {\n proxy.set('content', null);\n }\n }\n throw error;\n }\n if (isHasMany) {\n value.set('isLoaded', true);\n }\n relationship.state.hasFailedLoadAttempt = false;\n // only set to not stale if no error is thrown\n relationship.state.isStale = false;\n return value;\n }\n function assertRecordsPassedToHasMany(records) {\n // TODO only allow native arrays\n (!(Array.isArray(records) || EmberArray__default[\"default\"].detect(records)) && debug.assert(`You must pass an array of records to set a hasMany relationship`, Array.isArray(records) || EmberArray__default[\"default\"].detect(records)));\n (!(function () {\n return EmberArray.A(records).every(record => hasOwnProperty.call(record, '_internalModel') === true);\n }()) && debug.assert(`All elements of a hasMany relationship must be instances of Model, you passed ${debug.inspect(records)}`, function () {\n return EmberArray.A(records).every(record => hasOwnProperty.call(record, '_internalModel') === true);\n }()));\n }\n function extractRecordDatasFromRecords(records) {\n return records.map(extractRecordDataFromRecord);\n }\n function extractRecordDataFromRecord(recordOrPromiseRecord) {\n if (!recordOrPromiseRecord) {\n return null;\n }\n if (recordOrPromiseRecord.then) {\n let content = recordOrPromiseRecord.get && recordOrPromiseRecord.get('content');\n (!(content !== undefined) && debug.assert('You passed in a promise that did not originate from an EmberData relationship. You can only pass promises that come from a belongsTo or hasMany relationship to the get call.', content !== undefined));\n return content ? recordDataFor(content) : null;\n }\n return recordDataFor(recordOrPromiseRecord);\n }\n function anyUnloaded(store, relationship) {\n let state = relationship.currentState;\n const unloaded = state.find(s => {\n let im = store._internalModelForResource(s);\n return im._isDematerializing || !im.currentState.isLoaded;\n });\n return unloaded || false;\n }\n\n const AvailableShims = new WeakCache$1('schema-shims' );\n AvailableShims._generator = () => {\n return Object.create(null);\n };\n function getShimClass(store, modelName) {\n let shims = AvailableShims.lookup(store);\n let shim = shims[modelName];\n if (shim === undefined) {\n shim = shims[modelName] = new ShimModelClass(store, modelName);\n }\n return shim;\n }\n function mapFromHash(hash) {\n let map = new Map();\n for (let i in hash) {\n if (Object.prototype.hasOwnProperty.call(hash, i)) {\n map.set(i, hash[i]);\n }\n }\n return map;\n }\n\n // Mimics the static apis of DSModel\n class ShimModelClass {\n // TODO Maybe expose the class here?\n constructor(__store, modelName) {\n this.__store = __store;\n this.modelName = modelName;\n }\n get fields() {\n let attrs = this.__store._attributesDefinitionFor({\n type: this.modelName\n });\n let relationships = this.__store._relationshipsDefinitionFor({\n type: this.modelName\n });\n let fields = new Map();\n Object.keys(attrs).forEach(key => fields.set(key, 'attribute'));\n Object.keys(relationships).forEach(key => fields.set(key, relationships[key].kind));\n return fields;\n }\n get attributes() {\n let attrs = this.__store._attributesDefinitionFor({\n type: this.modelName\n });\n return mapFromHash(attrs);\n }\n get relationshipsByName() {\n let relationships = this.__store._relationshipsDefinitionFor({\n type: this.modelName\n });\n return mapFromHash(relationships);\n }\n eachAttribute(callback, binding) {\n let attrDefs = this.__store._attributesDefinitionFor({\n type: this.modelName\n });\n Object.keys(attrDefs).forEach(key => {\n callback.call(binding, key, attrDefs[key]);\n });\n }\n eachRelationship(callback, binding) {\n let relationshipDefs = this.__store._relationshipsDefinitionFor({\n type: this.modelName\n });\n Object.keys(relationshipDefs).forEach(key => {\n callback.call(binding, key, relationshipDefs[key]);\n });\n }\n eachTransformedAttribute(callback, binding) {\n let relationshipDefs = this.__store._relationshipsDefinitionFor({\n type: this.modelName\n });\n Object.keys(relationshipDefs).forEach(key => {\n if (relationshipDefs[key].type) {\n callback.call(binding, key, relationshipDefs[key]);\n }\n });\n }\n }\n\n /**\n @module @ember-data/store\n */\n\n /**\n SnapshotRecordArray is not directly instantiable.\n Instances are provided to consuming application's\n adapters for certain requests. \n\n @class SnapshotRecordArray\n @public\n */\n class SnapshotRecordArray {\n /**\n SnapshotRecordArray is not directly instantiable.\n Instances are provided to consuming application's\n adapters and serializers for certain requests. \n @method constructor\n @private\n @constructor\n @param {RecordArray} recordArray\n @param {Object} meta\n @param options \n */\n constructor(recordArray, meta, options = {}) {\n this._snapshots = void 0;\n this._recordArray = void 0;\n this._type = void 0;\n this.length = void 0;\n this.meta = void 0;\n this.adapterOptions = void 0;\n this.include = void 0;\n /**\n An array of snapshots\n @private\n @property _snapshots\n @type {Array}\n */\n this._snapshots = null;\n\n /**\n An array of records\n @private\n @property _recordArray\n @type {Array}\n */\n this._recordArray = recordArray;\n\n /**\n Number of records in the array\n Example\n ```app/adapters/post.js\n import JSONAPIAdapter from '@ember-data/adapter/json-api';\n export default class PostAdapter extends JSONAPIAdapter {\n shouldReloadAll(store, snapshotRecordArray) {\n return !snapshotRecordArray.length;\n }\n });\n ```\n @property length\n @public\n @type {Number}\n */\n this.length = recordArray.get('length');\n this._type = null;\n\n /**\n Meta objects for the record array.\n Example\n ```app/adapters/post.js\n import JSONAPIAdapter from '@ember-data/adapter/json-api';\n export default class PostAdapter extends JSONAPIAdapter {\n shouldReloadAll(store, snapshotRecordArray) {\n let lastRequestTime = snapshotRecordArray.meta.lastRequestTime;\n let twentyMinutes = 20 * 60 * 1000;\n return Date.now() > lastRequestTime + twentyMinutes;\n }\n });\n ```\n @property meta\n @public\n @type {Object}\n */\n this.meta = meta;\n\n /**\n A hash of adapter options passed into the store method for this request.\n Example\n ```app/adapters/post.js\n import MyCustomAdapter from './custom-adapter';\n export default class PostAdapter extends MyCustomAdapter {\n findAll(store, type, sinceToken, snapshotRecordArray) {\n if (snapshotRecordArray.adapterOptions.subscribe) {\n // ...\n }\n // ...\n }\n }\n ```\n @property adapterOptions\n @public\n @type {Object}\n */\n this.adapterOptions = options.adapterOptions;\n\n /**\n The relationships to include for this request.\n Example\n ```app/adapters/application.js\n import Adapter from '@ember-data/adapter';\n export default class ApplicationAdapter extends Adapter {\n findAll(store, type, snapshotRecordArray) {\n let url = `/${type.modelName}?include=${encodeURIComponent(snapshotRecordArray.include)}`;\n return fetch(url).then((response) => response.json())\n }\n }\n ```\n @property include\n @public\n @type {String|Array}\n */\n this.include = options.include;\n }\n\n /**\n The type of the underlying records for the snapshots in the array, as a Model\n @property type\n @public\n @type {Model}\n */\n get type() {\n return this._type || (this._type = this._recordArray.get('type'));\n }\n /**\n The modelName of the underlying records for the snapshots in the array, as a Model\n @property modelName\n @public\n @type {Model}\n */\n get modelName() {\n return this._recordArray.modelName;\n }\n\n /**\n Get snapshots of the underlying record array\n Example\n ```app/adapters/post.js\n import JSONAPIAdapter from '@ember-data/adapter/json-api';\n export default class PostAdapter extends JSONAPIAdapter {\n shouldReloadAll(store, snapshotArray) {\n let snapshots = snapshotArray.snapshots();\n return snapshots.any(function(ticketSnapshot) {\n let timeDiff = moment().diff(ticketSnapshot.attr('lastAccessedAt'), 'minutes');\n if (timeDiff > 20) {\n return true;\n } else {\n return false;\n }\n });\n }\n }\n ```\n @method snapshots\n @public\n @return {Array} Array of snapshots\n */\n snapshots() {\n if (this._snapshots !== null) {\n return this._snapshots;\n }\n this._snapshots = this._recordArray._takeSnapshot();\n return this._snapshots;\n }\n }\n\n function recordForIdentifier(store, identifier) {\n return internalModelFactoryFor(store).lookup(identifier).getRecord();\n }\n\n /**\n A record array is an array that contains records of a certain modelName. The record\n array materializes records as needed when they are retrieved for the first\n time. You should not create record arrays yourself. Instead, an instance of\n `RecordArray` or its subclasses will be returned by your application's store\n in response to queries.\n\n This class should not be imported and instantiated by consuming applications.\n\n @class RecordArray\n @public\n @extends Ember.ArrayProxy\n */\n\n let RecordArray = ArrayProxy__default[\"default\"].extend({\n init(args) {\n this._super(args);\n\n /**\n The array of client ids backing the record array. When a\n record is requested from the record array, the record\n for the client id at the same index is materialized, if\n necessary, by the store.\n @property content\n @private\n @type Ember.Array\n */\n this.set('content', this.content || null);\n\n /**\n The flag to signal a `RecordArray` is finished loading data.\n Example\n ```javascript\n let people = store.peekAll('person');\n people.get('isLoaded'); // true\n ```\n @property isLoaded\n @public\n @type Boolean\n */\n this.isLoaded = this.isLoaded || false;\n /**\n The flag to signal a `RecordArray` is currently loading data.\n Example\n ```javascript\n let people = store.peekAll('person');\n people.get('isUpdating'); // false\n people.update();\n people.get('isUpdating'); // true\n ```\n @property isUpdating\n @public\n @type Boolean\n */\n this.isUpdating = false;\n\n /**\n The store that created this record array.\n @property store\n @private\n @type Store\n */\n this.store = this.store || null;\n this._updatingPromise = null;\n },\n replace() {\n throw new Error(`The result of a server query (for all ${this.modelName} types) is immutable. To modify contents, use toArray()`);\n },\n /**\n The modelClass represented by this record array.\n @property type\n @public\n @type {subclass of Model}\n */\n type: object.computed('modelName', function () {\n if (!this.modelName) {\n return null;\n }\n return this.store.modelFor(this.modelName);\n }).readOnly(),\n /**\n Retrieves an object from the content by index.\n @method objectAtContent\n @private\n @param {Number} index\n @return {Model} record\n */\n objectAtContent(index) {\n let identifier = object.get(this, 'content').objectAt(index);\n return identifier ? recordForIdentifier(this.store, identifier) : undefined;\n },\n /**\n Used to get the latest version of all of the records in this array\n from the adapter.\n Example\n ```javascript\n let people = store.peekAll('person');\n people.get('isUpdating'); // false\n people.update().then(function() {\n people.get('isUpdating'); // false\n });\n people.get('isUpdating'); // true\n ```\n @method update\n @public\n */\n update() {\n if (object.get(this, 'isUpdating')) {\n return this._updatingPromise;\n }\n this.set('isUpdating', true);\n let updatingPromise = this._update().finally(() => {\n this._updatingPromise = null;\n if (this.get('isDestroying') || this.get('isDestroyed')) {\n return;\n }\n this.set('isUpdating', false);\n });\n this._updatingPromise = updatingPromise;\n return updatingPromise;\n },\n /*\n Update this RecordArray and return a promise which resolves once the update\n is finished.\n */\n _update() {\n return this.store.findAll(this.modelName, {\n reload: true\n });\n },\n /**\n Saves all of the records in the `RecordArray`.\n Example\n ```javascript\n let messages = store.peekAll('message');\n messages.forEach(function(message) {\n message.set('hasBeenSeen', true);\n });\n messages.save();\n ```\n @method save\n @public\n @return {PromiseArray} promise\n */\n save() {\n let promiseLabel = `DS: RecordArray#save ${this.modelName}`;\n let promise = RSVP.Promise.all(this.invoke('save'), promiseLabel).then(() => this, null, 'DS: RecordArray#save return RecordArray');\n return PromiseArray.create({\n promise\n });\n },\n /**\n @method _unregisterFromManager\n @internal\n */\n _unregisterFromManager() {\n this.manager.unregisterRecordArray(this);\n },\n willDestroy() {\n this._unregisterFromManager();\n this._dissociateFromOwnRecords();\n // TODO: we should not do work during destroy:\n // * when objects are destroyed, they should simply be left to do\n // * if logic errors do to this, that logic needs to be more careful during\n // teardown (ember provides isDestroying/isDestroyed) for this reason\n // * the exception being: if an dominator has a reference to this object,\n // and must be informed to release e.g. e.g. removing itself from th\n // recordArrayMananger\n object.set(this, 'content', null);\n object.set(this, 'length', 0);\n this._super(...arguments);\n },\n /**\n @method _createSnapshot\n @private\n */\n _createSnapshot(options) {\n // this is private for users, but public for ember-data internals\n return new SnapshotRecordArray(this, this.get('meta'), options);\n },\n /**\n @method _dissociateFromOwnRecords\n @internal\n */\n _dissociateFromOwnRecords() {\n this.get('content').forEach(identifier => {\n let recordArrays = this.manager.getRecordArraysForIdentifier(identifier);\n if (recordArrays) {\n recordArrays.delete(this);\n }\n });\n },\n /**\n Adds identifiers to the `RecordArray` without duplicates\n @method _pushIdentifiers\n @internal\n @param {StableRecordIdentifier[]} identifiers\n */\n _pushIdentifiers(identifiers) {\n object.get(this, 'content').pushObjects(identifiers);\n },\n /**\n Removes identifiers from the `RecordArray`.\n @method _removeIdentifiers\n @internal\n @param {StableRecordIdentifier[]} identifiers\n */\n _removeIdentifiers(identifiers) {\n object.get(this, 'content').removeObjects(identifiers);\n },\n /**\n @method _takeSnapshot\n @internal\n */\n _takeSnapshot() {\n return object.get(this, 'content').map(identifier => internalModelFactoryFor(this.store).lookup(identifier).createSnapshot());\n }\n });\n\n /**\n @module @ember-data/store\n */\n\n /**\n Represents an ordered list of records whose order and membership is\n determined by the adapter. For example, a query sent to the adapter\n may trigger a search on the server, whose results would be loaded\n into an instance of the `AdapterPopulatedRecordArray`.\n\n This class should not be imported and instantiated by consuming applications.\n\n ---\n\n If you want to update the array and get the latest records from the\n adapter, you can invoke [`update()`](AdapterPopulatedRecordArray/methods/update?anchor=update):\n\n Example\n\n ```javascript\n // GET /users?isAdmin=true\n store.query('user', { isAdmin: true }).then(function(admins) {\n\n admins.then(function() {\n console.log(admins.get(\"length\")); // 42\n });\n\n // somewhere later in the app code, when new admins have been created\n // in the meantime\n //\n // GET /users?isAdmin=true\n admins.update().then(function() {\n admins.get('isUpdating'); // false\n console.log(admins.get(\"length\")); // 123\n });\n\n admins.get('isUpdating'); // true\n }\n ```\n\n @class AdapterPopulatedRecordArray\n @public\n @extends RecordArray\n */\n var AdapterPopulatedRecordArray = RecordArray.extend({\n init() {\n this.set('content', this.get('content') || EmberArray.A());\n this._super(...arguments);\n this.query = this.query || null;\n this.links = this.links || null;\n },\n replace() {\n throw new Error(`The result of a server query (on ${this.modelName}) is immutable.`);\n },\n _update() {\n let store = object.get(this, 'store');\n let query = object.get(this, 'query');\n return store._query(this.modelName, query, this);\n },\n _setObjects(identifiersOrInternalModels, payload) {\n // TODO: initial load should not cause change events at all, only\n // subsequent. This requires changing the public api of adapter.query, but\n // hopefully we can do that soon.\n this.get('content').setObjects(identifiersOrInternalModels);\n this.setProperties({\n isLoaded: true,\n isUpdating: false,\n meta: {\n ...payload.meta\n },\n links: {\n ...payload.links\n }\n });\n this.manager._associateWithRecordArray(identifiersOrInternalModels, this);\n },\n /**\n @method _setIdentifiers\n @param {StableRecordIdentifier[]} identifiers\n @param {Object} payload normalized payload\n @private\n */\n _setIdentifiers(identifiers, payload) {\n this._setObjects(identifiers, payload);\n }\n });\n\n const RecordArraysCache = new WeakCache$1('record-arrays' );\n RecordArraysCache._generator = () => new Set();\n function recordArraysForIdentifier(identifierOrInternalModel) {\n return RecordArraysCache.lookup(identifierOrInternalModel);\n }\n const pendingForIdentifier = new Set([]);\n function getIdentifier(identifierOrInternalModel) {\n let i = identifierOrInternalModel;\n if (!isStableIdentifier(identifierOrInternalModel)) {\n // identifier may actually be an internalModel\n // but during materialization we will get an identifier that\n // has already been removed from the identifiers cache yet\n // so it will not behave as if stable. This is a bug we should fix.\n i = identifierOrInternalModel.identifier || i;\n }\n return i;\n }\n function shouldIncludeInRecordArrays(store, identifier) {\n const cache = internalModelFactoryFor(store);\n const internalModel = cache.peek(identifier);\n if (internalModel === null) {\n return false;\n }\n return !internalModel.isHiddenFromRecordArrays();\n }\n\n /**\n @class RecordArrayManager\n @internal\n */\n class RecordArrayManager {\n constructor(options) {\n this.store = options.store;\n this.isDestroying = false;\n this.isDestroyed = false;\n this._liveRecordArrays = Object.create(null);\n this._pendingIdentifiers = Object.create(null);\n this._adapterPopulatedRecordArrays = [];\n }\n\n /**\n * @method getRecordArraysForIdentifier\n * @internal\n * @param {StableIdentifier} param\n * @return {RecordArray} array\n */\n getRecordArraysForIdentifier(identifier) {\n return recordArraysForIdentifier(identifier);\n }\n _flushPendingIdentifiersForModelName(modelName, identifiers) {\n if (this.isDestroying || this.isDestroyed) {\n return;\n }\n let modelsToRemove = [];\n for (let j = 0; j < identifiers.length; j++) {\n let i = identifiers[j];\n // mark identifiers, so they can once again be processed by the\n // recordArrayManager\n pendingForIdentifier.delete(i);\n // build up a set of models to ensure we have purged correctly;\n let isIncluded = shouldIncludeInRecordArrays(this.store, i);\n if (!isIncluded) {\n modelsToRemove.push(i);\n }\n }\n let array = this._liveRecordArrays[modelName];\n if (array) {\n // TODO: skip if it only changed\n // process liveRecordArrays\n updateLiveRecordArray(this.store, array, identifiers);\n }\n\n // process adapterPopulatedRecordArrays\n if (modelsToRemove.length > 0) {\n removeFromAdapterPopulatedRecordArrays(this.store, modelsToRemove);\n }\n }\n _flush() {\n let pending = this._pendingIdentifiers;\n this._pendingIdentifiers = Object.create(null);\n for (let modelName in pending) {\n this._flushPendingIdentifiersForModelName(modelName, pending[modelName]);\n }\n }\n _syncLiveRecordArray(array, modelName) {\n (!(typeof modelName === 'string') && debug.assert(`recordArrayManger.syncLiveRecordArray expects modelName not modelClass as the second param`, typeof modelName === 'string'));\n let pending = this._pendingIdentifiers[modelName];\n let hasPendingChanges = Array.isArray(pending);\n let hasNoPotentialDeletions = !hasPendingChanges || pending.length === 0;\n let map = internalModelFactoryFor(this.store).modelMapFor(modelName);\n let hasNoInsertionsOrRemovals = object.get(map, 'length') === object.get(array, 'length');\n\n /*\n Ideally the recordArrayManager has knowledge of the changes to be applied to\n liveRecordArrays, and is capable of strategically flushing those changes and applying\n small diffs if desired. However, until we've refactored recordArrayManager, this dirty\n check prevents us from unnecessarily wiping out live record arrays returned by peekAll.\n */\n if (hasNoPotentialDeletions && hasNoInsertionsOrRemovals) {\n return;\n }\n if (hasPendingChanges) {\n this._flushPendingIdentifiersForModelName(modelName, pending);\n delete this._pendingIdentifiers[modelName];\n }\n let identifiers = this._visibleIdentifiersByType(modelName);\n let modelsToAdd = [];\n for (let i = 0; i < identifiers.length; i++) {\n let identifier = identifiers[i];\n let recordArrays = recordArraysForIdentifier(identifier);\n if (recordArrays.has(array) === false) {\n recordArrays.add(array);\n modelsToAdd.push(identifier);\n }\n }\n if (modelsToAdd.length) {\n array._pushIdentifiers(modelsToAdd);\n }\n }\n _didUpdateAll(modelName) {\n let recordArray = this._liveRecordArrays[modelName];\n if (recordArray) {\n object.set(recordArray, 'isUpdating', false);\n }\n }\n\n /**\n Get the `RecordArray` for a modelName, which contains all loaded records of\n given modelName.\n @method liveRecordArrayFor\n @internal\n @param {String} modelName\n @return {RecordArray}\n */\n liveRecordArrayFor(modelName) {\n (!(typeof modelName === 'string') && debug.assert(`recordArrayManger.liveRecordArrayFor expects modelName not modelClass as the param`, typeof modelName === 'string'));\n let array = this._liveRecordArrays[modelName];\n if (array) {\n // if the array already exists, synchronize\n this._syncLiveRecordArray(array, modelName);\n } else {\n // if the array is being newly created merely create it with its initial\n // content already set. This prevents unneeded change events.\n let identifiers = this._visibleIdentifiersByType(modelName);\n array = this.createRecordArray(modelName, identifiers);\n this._liveRecordArrays[modelName] = array;\n }\n return array;\n }\n _visibleIdentifiersByType(modelName) {\n let all = internalModelFactoryFor(this.store).modelMapFor(modelName).recordIdentifiers;\n let visible = [];\n for (let i = 0; i < all.length; i++) {\n let identifier = all[i];\n let shouldInclude = shouldIncludeInRecordArrays(this.store, identifier);\n if (shouldInclude) {\n visible.push(identifier);\n }\n }\n return visible;\n }\n\n /**\n Create a `RecordArray` for a modelName.\n @method createRecordArray\n @internal\n @param {String} modelName\n @param {Array} [identifiers]\n @return {RecordArray}\n */\n createRecordArray(modelName, identifiers) {\n (!(typeof modelName === 'string') && debug.assert(`recordArrayManger.createRecordArray expects modelName not modelClass as the param`, typeof modelName === 'string'));\n let array = RecordArray.create({\n modelName,\n content: EmberArray.A(identifiers || []),\n store: this.store,\n isLoaded: true,\n manager: this\n });\n if (Array.isArray(identifiers)) {\n this._associateWithRecordArray(identifiers, array);\n }\n return array;\n }\n\n /**\n Create a `AdapterPopulatedRecordArray` for a modelName with given query.\n @method createAdapterPopulatedRecordArray\n @internal\n @param {String} modelName\n @param {Object} query\n @return {AdapterPopulatedRecordArray}\n */\n createAdapterPopulatedRecordArray(modelName, query, identifiers, payload) {\n (!(typeof modelName === 'string') && debug.assert(`recordArrayManger.createAdapterPopulatedRecordArray expects modelName not modelClass as the first param, received ${modelName}`, typeof modelName === 'string'));\n let array;\n if (Array.isArray(identifiers)) {\n array = AdapterPopulatedRecordArray.create({\n modelName,\n query: query,\n content: EmberArray.A(identifiers),\n store: this.store,\n manager: this,\n isLoaded: true,\n isUpdating: false,\n meta: {\n ...payload.meta\n },\n links: {\n ...payload.links\n }\n });\n this._associateWithRecordArray(identifiers, array);\n } else {\n array = AdapterPopulatedRecordArray.create({\n modelName,\n query: query,\n content: EmberArray.A(),\n store: this.store,\n manager: this\n });\n }\n this._adapterPopulatedRecordArrays.push(array);\n return array;\n }\n\n /**\n Unregister a RecordArray.\n So manager will not update this array.\n @method unregisterRecordArray\n @internal\n @param {RecordArray} array\n */\n unregisterRecordArray(array) {\n let modelName = array.modelName;\n\n // remove from adapter populated record array\n let removedFromAdapterPopulated = removeFromArray(this._adapterPopulatedRecordArrays, array);\n if (!removedFromAdapterPopulated) {\n let liveRecordArrayForType = this._liveRecordArrays[modelName];\n // unregister live record array\n if (liveRecordArrayForType) {\n if (array === liveRecordArrayForType) {\n delete this._liveRecordArrays[modelName];\n }\n }\n }\n }\n\n /**\n * @method _associateWithRecordArray\n * @internal\n * @param {StableIdentifier} identifiers\n * @param {RecordArray} array\n */\n _associateWithRecordArray(identifiers, array) {\n for (let i = 0, l = identifiers.length; i < l; i++) {\n let identifier = identifiers[i];\n identifier = getIdentifier(identifier);\n let recordArrays = this.getRecordArraysForIdentifier(identifier);\n recordArrays.add(array);\n }\n }\n\n /**\n @method recordDidChange\n @internal\n */\n recordDidChange(identifier) {\n if (this.isDestroying || this.isDestroyed) {\n return;\n }\n let modelName = identifier.type;\n identifier = getIdentifier(identifier);\n if (pendingForIdentifier.has(identifier)) {\n return;\n }\n pendingForIdentifier.add(identifier);\n let pending = this._pendingIdentifiers;\n let models = pending[modelName] = pending[modelName] || [];\n if (models.push(identifier) !== 1) {\n return;\n }\n runloop._backburner.schedule('actions', this, this._flush);\n }\n willDestroy() {\n Object.keys(this._liveRecordArrays).forEach(modelName => this._liveRecordArrays[modelName].destroy());\n this._adapterPopulatedRecordArrays.forEach(entry => entry.destroy());\n this.isDestroyed = true;\n }\n destroy() {\n this.isDestroying = true;\n runloop._backburner.schedule('actions', this, this.willDestroy);\n }\n }\n function removeFromArray(array, item) {\n let index = array.indexOf(item);\n if (index !== -1) {\n array.splice(index, 1);\n return true;\n }\n return false;\n }\n function updateLiveRecordArray(store, recordArray, identifiers) {\n let identifiersToAdd = [];\n let identifiersToRemove = [];\n for (let i = 0; i < identifiers.length; i++) {\n let identifier = identifiers[i];\n let shouldInclude = shouldIncludeInRecordArrays(store, identifier);\n let recordArrays = recordArraysForIdentifier(identifier);\n if (shouldInclude) {\n if (!recordArrays.has(recordArray)) {\n identifiersToAdd.push(identifier);\n recordArrays.add(recordArray);\n }\n }\n if (!shouldInclude) {\n identifiersToRemove.push(identifier);\n recordArrays.delete(recordArray);\n }\n }\n if (identifiersToAdd.length > 0) {\n recordArray._pushIdentifiers(identifiersToAdd);\n }\n if (identifiersToRemove.length > 0) {\n recordArray._removeIdentifiers(identifiersToRemove);\n }\n }\n function removeFromAdapterPopulatedRecordArrays(store, identifiers) {\n for (let i = 0; i < identifiers.length; i++) {\n removeFromAll(store, identifiers[i]);\n }\n }\n function removeFromAll(store, identifier) {\n identifier = getIdentifier(identifier);\n const recordArrays = recordArraysForIdentifier(identifier);\n recordArrays.forEach(function (recordArray) {\n recordArray._removeIdentifiers([identifier]);\n });\n recordArrays.clear();\n }\n\n /**\n @module @ember-data/store\n */\n\n function payloadIsNotBlank(adapterPayload) {\n if (Array.isArray(adapterPayload)) {\n return true;\n } else {\n return Object.keys(adapterPayload || {}).length;\n }\n }\n function iterateData(data, fn) {\n if (Array.isArray(data)) {\n return data.map(fn);\n } else {\n return fn(data);\n }\n }\n\n // sync\n // iterate over records in payload.data\n // for each record\n // assert that record.relationships[inverse] is either undefined (so we can fix it)\n // or provide a data: {id, type} that matches the record that requested it\n // return the relationship data for the parent\n function syncRelationshipDataFromLink(store, payload, parentInternalModel, relationship) {\n // ensure the right hand side (incoming payload) points to the parent record that\n // requested this relationship\n let relationshipData = payload.data ? iterateData(payload.data, (data, index) => {\n const {\n id,\n type\n } = data;\n ensureRelationshipIsSetToParent(data, parentInternalModel, store, relationship, index);\n return {\n id,\n type\n };\n }) : null;\n const relatedDataHash = {};\n if ('meta' in payload) {\n relatedDataHash.meta = payload.meta;\n }\n if ('links' in payload) {\n relatedDataHash.links = payload.links;\n }\n if ('data' in payload) {\n relatedDataHash.data = relationshipData;\n }\n\n // now, push the left hand side (the parent record) to ensure things are in sync, since\n // the payload will be pushed with store._push\n const parentPayload = {\n id: parentInternalModel.id,\n type: parentInternalModel.modelName,\n relationships: {\n [relationship.key]: relatedDataHash\n }\n };\n if (!Array.isArray(payload.included)) {\n payload.included = [];\n }\n payload.included.push(parentPayload);\n return payload;\n }\n function ensureRelationshipIsSetToParent(payload, parentInternalModel, store, parentRelationship, index) {\n let {\n id,\n type\n } = payload;\n if (!payload.relationships) {\n payload.relationships = {};\n }\n let {\n relationships\n } = payload;\n let inverse = getInverse(store, parentInternalModel, parentRelationship, type);\n if (inverse) {\n let {\n inverseKey,\n kind\n } = inverse;\n let relationshipData = relationships[inverseKey] && relationships[inverseKey].data;\n if (typeof relationshipData !== 'undefined' && !relationshipDataPointsToParent(relationshipData, parentInternalModel)) {\n let inspect = function inspect(thing) {\n return `'${JSON.stringify(thing)}'`;\n };\n let quotedType = inspect(type);\n let quotedInverse = inspect(inverseKey);\n let expected = inspect({\n id: parentInternalModel.id,\n type: parentInternalModel.modelName\n });\n let expectedModel = `${parentInternalModel.modelName}:${parentInternalModel.id}`;\n let got = inspect(relationshipData);\n let prefix = typeof index === 'number' ? `data[${index}]` : `data`;\n let path = `${prefix}.relationships.${inverseKey}.data`;\n let other = relationshipData ? `<${relationshipData.type}:${relationshipData.id}>` : null;\n let relationshipFetched = `${expectedModel}.${parentRelationship.kind}(\"${parentRelationship.name}\")`;\n let includedRecord = `<${type}:${id}>`;\n let message = [`Encountered mismatched relationship: Ember Data expected ${path} in the payload from ${relationshipFetched} to include ${expected} but got ${got} instead.\\n`, `The ${includedRecord} record loaded at ${prefix} in the payload specified ${other} as its ${quotedInverse}, but should have specified ${expectedModel} (the record the relationship is being loaded from) as its ${quotedInverse} instead.`, `This could mean that the response for ${relationshipFetched} may have accidentally returned ${quotedType} records that aren't related to ${expectedModel} and could be related to a different ${parentInternalModel.modelName} record instead.`, `Ember Data has corrected the ${includedRecord} record's ${quotedInverse} relationship to ${expectedModel} so that ${relationshipFetched} will include ${includedRecord}.`, `Please update the response from the server or change your serializer to either ensure that the response for only includes ${quotedType} records that specify ${expectedModel} as their ${quotedInverse}, or omit the ${quotedInverse} relationship from the response.`].join('\\n');\n (debug.assert(message));\n }\n if (kind !== 'hasMany' || typeof relationshipData !== 'undefined') {\n relationships[inverseKey] = relationships[inverseKey] || {};\n relationships[inverseKey].data = fixRelationshipData(relationshipData, kind, parentInternalModel);\n }\n }\n }\n function getInverse(store, parentInternalModel, parentRelationship, type) {\n return recordDataFindInverseRelationshipInfo(store, parentInternalModel, parentRelationship, type);\n }\n function recordDataFindInverseRelationshipInfo({\n _storeWrapper\n }, parentInternalModel, parentRelationship, type) {\n let {\n name: lhs_relationshipName\n } = parentRelationship;\n let {\n modelName\n } = parentInternalModel;\n let inverseKey = _storeWrapper.inverseForRelationship(modelName, lhs_relationshipName);\n if (inverseKey) {\n let {\n meta: {\n kind\n }\n } = _storeWrapper.relationshipsDefinitionFor(type)[inverseKey];\n return {\n inverseKey,\n kind\n };\n }\n }\n function relationshipDataPointsToParent(relationshipData, internalModel) {\n if (relationshipData === null) {\n return false;\n }\n if (Array.isArray(relationshipData)) {\n if (relationshipData.length === 0) {\n return false;\n }\n for (let i = 0; i < relationshipData.length; i++) {\n let entry = relationshipData[i];\n if (validateRelationshipEntry(entry, internalModel)) {\n return true;\n }\n }\n } else {\n return validateRelationshipEntry(relationshipData, internalModel);\n }\n return false;\n }\n function fixRelationshipData(relationshipData, relationshipKind, {\n id,\n modelName\n }) {\n let parentRelationshipData = {\n id,\n type: modelName\n };\n let payload;\n if (relationshipKind === 'hasMany') {\n payload = relationshipData || [];\n if (relationshipData) {\n // these arrays could be massive so this is better than filter\n // Note: this is potentially problematic if type/id are not in the\n // same state of normalization.\n let found = relationshipData.find(v => {\n return v.type === parentRelationshipData.type && v.id === parentRelationshipData.id;\n });\n if (!found) {\n payload.push(parentRelationshipData);\n }\n } else {\n payload.push(parentRelationshipData);\n }\n } else {\n payload = relationshipData || {};\n Object.assign(payload, parentRelationshipData);\n }\n return payload;\n }\n function validateRelationshipEntry({\n id\n }, {\n id: parentModelID\n }) {\n return id && id.toString() === parentModelID;\n }\n function _findHasMany(adapter, store, internalModel, link, relationship, options) {\n let snapshot = internalModel.createSnapshot(options);\n let modelClass = store.modelFor(relationship.type);\n let useLink = !link || typeof link === 'string';\n let relatedLink = useLink ? link : link.href;\n let promise = adapter.findHasMany(store, snapshot, relatedLink, relationship);\n let label = `DS: Handle Adapter#findHasMany of '${internalModel.modelName}' : '${relationship.type}'`;\n promise = guardDestroyedStore(promise, store, label);\n promise = _guard(promise, _bind(_objectIsAlive, internalModel));\n return promise.then(adapterPayload => {\n (!(payloadIsNotBlank(adapterPayload)) && debug.assert(`You made a 'findHasMany' request for a ${internalModel.modelName}'s '${relationship.key}' relationship, using link '${link}' , but the adapter's response did not have any data`, payloadIsNotBlank(adapterPayload)));\n let serializer = store.serializerFor(relationship.type);\n let payload = normalizeResponseHelper(serializer, store, modelClass, adapterPayload, null, 'findHasMany');\n (!('data' in payload && Array.isArray(payload.data)) && debug.assert(`fetched the hasMany relationship '${relationship.name}' for ${internalModel.modelName}:${internalModel.id} with link '${link}', but no data member is present in the response. If no data exists, the response should set { data: [] }`, 'data' in payload && Array.isArray(payload.data)));\n payload = syncRelationshipDataFromLink(store, payload, internalModel, relationship);\n let internalModelArray = store._push(payload);\n return internalModelArray;\n }, null, `DS: Extract payload of '${internalModel.modelName}' : hasMany '${relationship.type}'`);\n }\n function _findBelongsTo(adapter, store, internalModel, link, relationship, options) {\n let snapshot = internalModel.createSnapshot(options);\n let modelClass = store.modelFor(relationship.type);\n let useLink = !link || typeof link === 'string';\n let relatedLink = useLink ? link : link.href;\n let promise = adapter.findBelongsTo(store, snapshot, relatedLink, relationship);\n let label = `DS: Handle Adapter#findBelongsTo of ${internalModel.modelName} : ${relationship.type}`;\n promise = guardDestroyedStore(promise, store, label);\n promise = _guard(promise, _bind(_objectIsAlive, internalModel));\n return promise.then(adapterPayload => {\n let serializer = store.serializerFor(relationship.type);\n let payload = normalizeResponseHelper(serializer, store, modelClass, adapterPayload, null, 'findBelongsTo');\n (!('data' in payload && (payload.data === null || typeof payload.data === 'object' && !Array.isArray(payload.data))) && debug.assert(`fetched the belongsTo relationship '${relationship.name}' for ${internalModel.modelName}:${internalModel.id} with link '${link}', but no data member is present in the response. If no data exists, the response should set { data: null }`, 'data' in payload && (payload.data === null || typeof payload.data === 'object' && !Array.isArray(payload.data))));\n if (!payload.data && !payload.links && !payload.meta) {\n return null;\n }\n payload = syncRelationshipDataFromLink(store, payload, internalModel, relationship);\n return store._push(payload);\n }, null, `DS: Extract payload of ${internalModel.modelName} : ${relationship.type}`);\n }\n function _findAll(adapter, store, modelName, options) {\n let modelClass = store.modelFor(modelName); // adapter.findAll depends on the class\n let recordArray = store.peekAll(modelName);\n let snapshotArray = recordArray._createSnapshot(options);\n let promise = RSVP.Promise.resolve().then(() => adapter.findAll(store, modelClass, null, snapshotArray));\n let label = 'DS: Handle Adapter#findAll of ' + modelClass;\n promise = guardDestroyedStore(promise, store, label);\n return promise.then(adapterPayload => {\n (!(payloadIsNotBlank(adapterPayload)) && debug.assert(`You made a 'findAll' request for '${modelName}' records, but the adapter's response did not have any data`, payloadIsNotBlank(adapterPayload)));\n let serializer = store.serializerFor(modelName);\n let payload = normalizeResponseHelper(serializer, store, modelClass, adapterPayload, null, 'findAll');\n store._push(payload);\n store._didUpdateAll(modelName);\n return recordArray;\n }, null, 'DS: Extract payload of findAll ${modelName}');\n }\n function _query(adapter, store, modelName, query, recordArray, options) {\n let modelClass = store.modelFor(modelName); // adapter.query needs the class\n\n recordArray = recordArray || store.recordArrayManager.createAdapterPopulatedRecordArray(modelName, query);\n let promise = RSVP.Promise.resolve().then(() => adapter.query(store, modelClass, query, recordArray, options));\n let label = `DS: Handle Adapter#query of ${modelName}`;\n promise = guardDestroyedStore(promise, store, label);\n return promise.then(adapterPayload => {\n let serializer = store.serializerFor(modelName);\n let payload = normalizeResponseHelper(serializer, store, modelClass, adapterPayload, null, 'query');\n let internalModels = store._push(payload);\n (!(Array.isArray(internalModels)) && debug.assert('The response to store.query is expected to be an array but it was a single record. Please wrap your response in an array or use `store.queryRecord` to query for a single record.', Array.isArray(internalModels)));\n let identifiers = internalModels.map(im => im.identifier);\n if (recordArray) {\n recordArray._setIdentifiers(identifiers, payload);\n } else {\n recordArray = store.recordArrayManager.createAdapterPopulatedRecordArray(modelName, query, identifiers, payload);\n }\n return recordArray;\n }, null, `DS: Extract payload of query ${modelName}`);\n }\n function _queryRecord(adapter, store, modelName, query, options) {\n let modelClass = store.modelFor(modelName); // adapter.queryRecord needs the class\n let promise = RSVP.Promise.resolve().then(() => adapter.queryRecord(store, modelClass, query, options));\n let label = `DS: Handle Adapter#queryRecord of ${modelName}`;\n promise = guardDestroyedStore(promise, store, label);\n return promise.then(adapterPayload => {\n let serializer = store.serializerFor(modelName);\n let payload = normalizeResponseHelper(serializer, store, modelClass, adapterPayload, null, 'queryRecord');\n (!(!Array.isArray(payload.data)) && debug.assert(`Expected the primary data returned by the serializer for a 'queryRecord' response to be a single object or null but instead it was an array.`, !Array.isArray(payload.data)));\n return store._push(payload);\n }, null, `DS: Extract payload of queryRecord ${modelName}`);\n }\n\n /**\n @module @ember-data/store\n */\n\n function metaIsRelationshipDefinition(meta) {\n return typeof meta._inverseKey === 'function';\n }\n let peekGraph;\n {\n let _peekGraph;\n peekGraph = wrapper => {\n _peekGraph = _peekGraph || require('@ember-data/record-data/-private').peekGraph;\n return _peekGraph(wrapper);\n };\n }\n class RecordDataStoreWrapper {\n constructor(_store) {\n this._store = _store;\n this._willNotify = false;\n this._pendingNotifies = new Map();\n }\n get identifierCache() {\n return this._store.identifierCache;\n }\n _scheduleNotification(identifier, key, kind) {\n let pending = this._pendingNotifies.get(identifier);\n if (!pending) {\n pending = new Map();\n this._pendingNotifies.set(identifier, pending);\n }\n pending.set(key, kind);\n if (this._willNotify === true) {\n return;\n }\n this._willNotify = true;\n let backburner = this._store._backburner;\n backburner.schedule('notify', this, this._flushNotifications);\n }\n notifyErrorsChange(type, id, lid) {\n const resource = constructResource(type, id, lid);\n const identifier = this.identifierCache.getOrCreateRecordIdentifier(resource);\n let internalModel = internalModelFactoryFor(this._store).peek(identifier);\n if (internalModel) {\n internalModel.notifyErrorsChange();\n }\n }\n _flushNotifications() {\n if (this._willNotify === false) {\n return;\n }\n let pending = this._pendingNotifies;\n this._pendingNotifies = new Map();\n this._willNotify = false;\n const factory = internalModelFactoryFor(this._store);\n pending.forEach((map, identifier) => {\n const internalModel = factory.peek(identifier);\n if (internalModel) {\n map.forEach((kind, key) => {\n if (kind === 'belongsTo') {\n internalModel.notifyBelongsToChange(key);\n } else {\n internalModel.notifyHasManyChange(key);\n }\n });\n }\n });\n }\n attributesDefinitionFor(type) {\n return this._store._attributesDefinitionFor({\n type\n });\n }\n relationshipsDefinitionFor(type) {\n return this._store._relationshipsDefinitionFor({\n type\n });\n }\n inverseForRelationship(type, key) {\n const modelClass = this._store.modelFor(type);\n const definition = this.relationshipsDefinitionFor(type)[key];\n if (!definition) {\n return null;\n }\n if (metaIsRelationshipDefinition(definition)) {\n return definition._inverseKey(this._store, modelClass);\n } else if (definition.options && definition.options.inverse !== undefined) {\n return definition.options.inverse;\n } else {\n return null;\n }\n }\n inverseIsAsyncForRelationship(type, key) {\n const modelClass = this._store.modelFor(type);\n const definition = this.relationshipsDefinitionFor(type)[key];\n if (!definition) {\n return false;\n }\n if (definition.options && definition.options.inverse === null) {\n return false;\n }\n if (definition.inverseIsAsync !== undefined) {\n // TODO do we need to amend the RFC for this prop?\n // else we should add it to the TS interface and document.\n return !!definition.inverseIsAsync;\n } else if (metaIsRelationshipDefinition(definition)) {\n return definition._inverseIsAsync(this._store, modelClass);\n } else {\n return false;\n }\n }\n notifyPropertyChange(type, id, lid, key) {\n const resource = constructResource(type, id, lid);\n const identifier = this.identifierCache.getOrCreateRecordIdentifier(resource);\n let internalModel = internalModelFactoryFor(this._store).peek(identifier);\n if (internalModel) {\n internalModel.notifyPropertyChange(key);\n }\n }\n notifyHasManyChange(type, id, lid, key) {\n const resource = constructResource(type, id, lid);\n const identifier = this.identifierCache.getOrCreateRecordIdentifier(resource);\n this._scheduleNotification(identifier, key, 'hasMany');\n }\n notifyBelongsToChange(type, id, lid, key) {\n const resource = constructResource(type, id, lid);\n const identifier = this.identifierCache.getOrCreateRecordIdentifier(resource);\n this._scheduleNotification(identifier, key, 'belongsTo');\n }\n notifyStateChange(type, id, lid, key) {\n const resource = constructResource(type, id, lid);\n const identifier = this.identifierCache.getOrCreateRecordIdentifier(resource);\n let internalModel = internalModelFactoryFor(this._store).peek(identifier);\n if (internalModel) {\n internalModel.notifyStateChange(key);\n }\n }\n recordDataFor(type, id, lid) {\n let identifier;\n let isCreate = false;\n if (!id && !lid) {\n isCreate = true;\n identifier = {\n type\n };\n } else {\n const resource = constructResource(type, id, lid);\n identifier = this.identifierCache.getOrCreateRecordIdentifier(resource);\n }\n return this._store.recordDataFor(identifier, isCreate);\n }\n setRecordId(type, id, lid) {\n this._store.setRecordId(type, id, lid);\n }\n isRecordInUse(type, id, lid) {\n const resource = constructResource(type, id, lid);\n const identifier = this.identifierCache.getOrCreateRecordIdentifier(resource);\n const internalModel = internalModelFactoryFor(this._store).peek(identifier);\n if (!internalModel) {\n return false;\n }\n const record = internalModel._record;\n return record && !(record.isDestroyed || record.isDestroying);\n }\n disconnectRecord(type, id, lid) {\n const resource = constructResource(type, id, lid);\n const identifier = this.identifierCache.getOrCreateRecordIdentifier(resource);\n {\n let graph = peekGraph(this);\n if (graph) {\n graph.remove(identifier);\n }\n }\n let internalModel = internalModelFactoryFor(this._store).peek(identifier);\n if (internalModel) {\n internalModel.destroyFromRecordData();\n }\n }\n }\n\n let _RecordData;\n const {\n ENV\n } = Ember__default[\"default\"];\n const RECORD_REFERENCES = new WeakCache$1('reference' );\n function freeze(obj) {\n if (typeof Object.freeze === 'function') {\n return Object.freeze(obj);\n }\n return obj;\n }\n\n /**\n The store contains all of the data for records loaded from the server.\n It is also responsible for creating instances of `Model` that wrap\n the individual data for a record, so that they can be bound to in your\n Handlebars templates.\n\n Define your application's store like this:\n\n ```app/services/store.js\n import Store from '@ember-data/store';\n\n export default class MyStore extends Store {}\n ```\n\n Most Ember.js applications will only have a single `Store` that is\n automatically created by their `Ember.Application`.\n\n You can retrieve models from the store in several ways. To retrieve a record\n for a specific id, use `Store`'s `findRecord()` method:\n\n ```javascript\n store.findRecord('person', 123).then(function (person) {\n });\n ```\n\n By default, the store will talk to your backend using a standard\n REST mechanism. You can customize how the store talks to your\n backend by specifying a custom adapter:\n\n ```app/adapters/application.js\n import Adapter from '@ember-data/adapter';\n\n export default class ApplicationAdapter extends Adapter {\n }\n ```\n\n You can learn more about writing a custom adapter by reading the `Adapter`\n documentation.\n\n ### Store createRecord() vs. push() vs. pushPayload()\n\n The store provides multiple ways to create new record objects. They have\n some subtle differences in their use which are detailed below:\n\n [createRecord](../methods/createRecord?anchor=createRecord) is used for creating new\n records on the client side. This will return a new record in the\n `created.uncommitted` state. In order to persist this record to the\n backend, you will need to call `record.save()`.\n\n [push](../methods/push?anchor=push) is used to notify Ember Data's store of new or\n updated records that exist in the backend. This will return a record\n in the `loaded.saved` state. The primary use-case for `store#push` is\n to notify Ember Data about record updates (full or partial) that happen\n outside of the normal adapter methods (for example\n [SSE](http://dev.w3.org/html5/eventsource/) or [Web\n Sockets](http://www.w3.org/TR/2009/WD-websockets-20091222/)).\n\n [pushPayload](../methods/pushPayload?anchor=pushPayload) is a convenience wrapper for\n `store#push` that will deserialize payloads if the\n Serializer implements a `pushPayload` method.\n\n Note: When creating a new record using any of the above methods\n Ember Data will update `RecordArray`s such as those returned by\n `store#peekAll()` or `store#findAll()`. This means any\n data bindings or computed properties that depend on the RecordArray\n will automatically be synced to include the new or updated record\n values.\n\n @main @ember-data/store\n @class Store\n @public\n @extends Ember.Service\n */\n\n class CoreStore extends Service__default[\"default\"] {\n /**\n The default adapter to use to communicate to a backend server or\n other persistence layer. This will be overridden by an application\n adapter if present.\n If you want to specify `app/adapters/custom.js` as a string, do:\n ```js\n import Store from '@ember-data/store';\n export default Store.extend({\n constructor() {\n super(...arguments);\n this.adapter = 'custom';\n }\n }\n ```\n @property adapter\n @public\n @default '-json-api'\n @type {String}\n */\n\n /**\n This property returns the adapter, after resolving a possible\n string key.\n If the supplied `adapter` was a class, or a String property\n path resolved to a class, this property will instantiate the\n class.\n This property is cacheable, so the same instance of a specified\n adapter class should be used for the lifetime of the store.\n @property defaultAdapter\n @private\n @return Adapter\n */\n\n /**\n @method init\n @private\n */\n constructor() {\n super(...arguments);\n /**\n * EmberData specific backburner instance\n * @property _backburner\n * @private\n */\n this._backburner = backburner;\n this.recordArrayManager = new RecordArrayManager({\n store: this\n });\n this._adapterCache = Object.create(null);\n this._serializerCache = Object.create(null);\n this._storeWrapper = new RecordDataStoreWrapper(this);\n /*\n Ember Data uses several specialized micro-queues for organizing\n and coalescing similar async work.\n These queues are currently controlled by a flush scheduled into\n ember-data's custom backburner instance.\n */\n // used for coalescing internal model updates\n this._updatedInternalModels = [];\n this.shouldTrackAsyncRequests = false;\n this.generateStackTracesForTrackedRequests = false;\n RECORD_REFERENCES._generator = identifier => {\n return new RecordReference(this, identifier);\n };\n this._fetchManager = new FetchManager(this);\n this._notificationManager = new NotificationManager(this);\n this.__recordDataFor = this.__recordDataFor.bind(this);\n\n /**\n * Provides access to the IdentifierCache instance\n * for this store.\n *\n * The IdentifierCache can be used to generate or\n * retrieve a stable unique identifier for any resource.\n *\n * @property {IdentifierCache} identifierCache\n * @public\n */\n this.identifierCache = new IdentifierCache();\n {\n if (this.shouldTrackAsyncRequests === undefined) {\n this.shouldTrackAsyncRequests = false;\n }\n if (this.generateStackTracesForTrackedRequests === undefined) {\n this.generateStackTracesForTrackedRequests = false;\n }\n this._trackedAsyncRequests = [];\n this._trackAsyncRequestStart = label => {\n let trace = 'set `store.generateStackTracesForTrackedRequests = true;` to get a detailed trace for where this request originated';\n if (this.generateStackTracesForTrackedRequests) {\n try {\n throw new Error(`EmberData TrackedRequest: ${label}`);\n } catch (e) {\n trace = e;\n }\n }\n let token = freeze({\n label,\n trace\n });\n this._trackedAsyncRequests.push(token);\n return token;\n };\n this._trackAsyncRequestEnd = token => {\n let index = this._trackedAsyncRequests.indexOf(token);\n if (index === -1) {\n throw new Error(`Attempted to end tracking for the following request but it was not being tracked:\\n${token}`);\n }\n this._trackedAsyncRequests.splice(index, 1);\n };\n this.__asyncWaiter = () => {\n let shouldTrack = this.shouldTrackAsyncRequests;\n let tracked = this._trackedAsyncRequests;\n let isSettled = tracked.length === 0;\n return shouldTrack !== true || isSettled;\n };\n test.registerWaiter(this.__asyncWaiter);\n }\n }\n getRequestStateService() {\n return this._fetchManager.requestCache;\n }\n _instantiateRecord(internalModel, modelName, recordData, identifier, properties) {\n // assert here\n if (properties !== undefined) {\n (!(typeof properties === 'object' && properties !== null) && debug.assert(`You passed '${properties}' as properties for record creation instead of an object.`, typeof properties === 'object' && properties !== null));\n if ('id' in properties) {\n internalModel.setId(properties.id);\n }\n\n // convert relationship Records to RecordDatas before passing to RecordData\n let defs = this._relationshipsDefinitionFor({\n type: modelName\n });\n if (defs !== null) {\n let keys = Object.keys(properties);\n let relationshipValue;\n for (let i = 0; i < keys.length; i++) {\n let prop = keys[i];\n let def = defs[prop];\n if (def !== undefined) {\n if (def.kind === 'hasMany') {\n {\n assertRecordsPassedToHasMany(properties[prop]);\n }\n relationshipValue = extractRecordDatasFromRecords(properties[prop]);\n } else {\n relationshipValue = extractRecordDataFromRecord(properties[prop]);\n }\n properties[prop] = relationshipValue;\n }\n }\n }\n }\n\n // TODO guard against initRecordOptions no being there\n let createOptions = recordData._initRecordCreateOptions(properties);\n //TODO Igor pass a wrapper instead of RD\n let record = this.instantiateRecord(identifier, createOptions, this.__recordDataFor, this._notificationManager);\n setRecordIdentifier(record, identifier);\n //recordToInternalModelMap.set(record, internalModel);\n return record;\n }\n _internalDeleteRecord(internalModel) {\n internalModel.deleteRecord();\n }\n\n // FeatureFlagged in the DSModelStore claas\n _attributesDefinitionFor(identifier) {\n return this.getSchemaDefinitionService().attributesDefinitionFor(identifier);\n }\n _relationshipsDefinitionFor(identifier) {\n return this.getSchemaDefinitionService().relationshipsDefinitionFor(identifier);\n }\n registerSchemaDefinitionService(schema) {\n this._schemaDefinitionService = schema;\n }\n getSchemaDefinitionService() {\n return this._schemaDefinitionService;\n }\n\n // TODO Double check this return value is correct\n _relationshipMetaFor(modelName, id, key) {\n return this._relationshipsDefinitionFor({\n type: modelName\n })[key];\n }\n\n /**\n Returns the schema for a particular `modelName`.\n When used with Model from @ember-data/model the return is the model class,\n but this is not guaranteed.\n The class of a model might be useful if you want to get a list of all the\n relationship names of the model, see\n [`relationshipNames`](/ember-data/release/classes/Model?anchor=relationshipNames)\n for example.\n @method modelFor\n @public\n @param {String} modelName\n @return {subclass of Model | ShimModelClass}\n */\n modelFor(modelName) {\n {\n assertDestroyedStoreOnly$1(this, 'modelFor');\n }\n return getShimClass(this, modelName);\n }\n\n // Feature Flagged in DSModelStore\n /**\n Returns whether a ModelClass exists for a given modelName\n This exists for legacy support for the RESTSerializer,\n which due to how it must guess whether a key is a model\n must query for whether a match exists.\n We should investigate an RFC to make this public or removing\n this requirement.\n @method _hasModelFor\n @private\n */\n _hasModelFor(modelName) {\n (!(utils.isPresent(modelName)) && debug.assert(`You need to pass a model name to the store's hasModelFor method`, utils.isPresent(modelName)));\n (!(typeof modelName === 'string') && debug.assert(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${modelName}`, typeof modelName === 'string'));\n return this.getSchemaDefinitionService().doesTypeExist(modelName);\n }\n\n // .....................\n // . CREATE NEW RECORD .\n // .....................\n\n /**\n Create a new record in the current store. The properties passed\n to this method are set on the newly created record.\n To create a new instance of a `Post`:\n ```js\n store.createRecord('post', {\n title: 'Ember is awesome!'\n });\n ```\n To create a new instance of a `Post` that has a relationship with a `User` record:\n ```js\n let user = this.store.peekRecord('user', 1);\n store.createRecord('post', {\n title: 'Ember is awesome!',\n user: user\n });\n ```\n @method createRecord\n @public\n @param {String} modelName\n @param {Object} inputProperties a hash of properties to set on the\n newly created record.\n @return {Model} record\n */\n createRecord(modelName, inputProperties) {\n {\n assertDestroyingStore$1(this, 'createRecord');\n }\n (!(utils.isPresent(modelName)) && debug.assert(`You need to pass a model name to the store's createRecord method`, utils.isPresent(modelName)));\n (!(typeof modelName === 'string') && debug.assert(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${modelName}`, typeof modelName === 'string')); // This is wrapped in a `run.join` so that in test environments users do not need to manually wrap\n // calls to `createRecord`. The run loop usage here is because we batch the joining and updating\n // of record-arrays via ember's run loop, not our own.\n //\n // to remove this, we would need to move to a new `async` API.\n return runloop._backburner.join(() => {\n return this._backburner.join(() => {\n let normalizedModelName = normalizeModelName(modelName);\n let properties = {\n ...inputProperties\n };\n\n // If the passed properties do not include a primary key,\n // give the adapter an opportunity to generate one. Typically,\n // client-side ID generators will use something like uuid.js\n // to avoid conflicts.\n\n if (utils.isNone(properties.id)) {\n properties.id = this._generateId(normalizedModelName, properties);\n }\n\n // Coerce ID to a string\n properties.id = coerceId(properties.id);\n const factory = internalModelFactoryFor(this);\n const internalModel = factory.build({\n type: normalizedModelName,\n id: properties.id\n });\n internalModel.send('loadedData');\n // TODO this exists just to proxy `isNew` to RecordData which is weird\n internalModel.didCreateRecord();\n return internalModel.getRecord(properties);\n });\n });\n }\n\n /**\n If possible, this method asks the adapter to generate an ID for\n a newly created record.\n @method _generateId\n @private\n @param {String} modelName\n @param {Object} properties from the new record\n @return {String} if the adapter can generate one, an ID\n */\n _generateId(modelName, properties) {\n let adapter = this.adapterFor(modelName);\n if (adapter && adapter.generateIdForRecord) {\n return adapter.generateIdForRecord(this, modelName, properties);\n }\n return null;\n }\n\n // .................\n // . DELETE RECORD .\n // .................\n\n /**\n For symmetry, a record can be deleted via the store.\n Example\n ```javascript\n let post = store.createRecord('post', {\n title: 'Ember is awesome!'\n });\n store.deleteRecord(post);\n ```\n @method deleteRecord\n @public\n @param {Model} record\n */\n deleteRecord(record) {\n {\n assertDestroyingStore$1(this, 'deleteRecord');\n }\n this._backburner.join(() => {\n let identifier = peekRecordIdentifier(record);\n if (identifier) {\n let internalModel = internalModelFactoryFor(this).peek(identifier);\n if (internalModel) {\n internalModel.deleteRecord();\n }\n }\n });\n }\n\n /**\n For symmetry, a record can be unloaded via the store.\n This will cause the record to be destroyed and freed up for garbage collection.\n Example\n ```javascript\n store.findRecord('post', 1).then(function(post) {\n store.unloadRecord(post);\n });\n ```\n @method unloadRecord\n @public\n @param {Model} record\n */\n unloadRecord(record) {\n {\n assertDestroyingStore$1(this, 'unloadRecord');\n }\n let identifier = peekRecordIdentifier(record);\n if (identifier) {\n let internalModel = internalModelFactoryFor(this).peek(identifier);\n if (internalModel) {\n internalModel.unloadRecord();\n }\n }\n }\n\n // ................\n // . FIND RECORDS .\n // ................\n\n /**\n @method find\n @param {String} modelName\n @param {String|Integer} id\n @param {Object} options\n @return {Promise} promise\n @private\n */\n find(modelName, id, options) {\n {\n assertDestroyingStore$1(this, 'find');\n }\n // The default `model` hook in Route calls `find(modelName, id)`,\n // that's why we have to keep this method around even though `findRecord` is\n // the public way to get a record by modelName and id.\n (!(arguments.length !== 1) && debug.assert(`Using store.find(type) has been removed. Use store.findAll(modelName) to retrieve all records for a given type.`, arguments.length !== 1));\n (!(!options) && debug.assert(`Calling store.find(modelName, id, { preload: preload }) is no longer supported. Use store.findRecord(modelName, id, { preload: preload }) instead.`, !options));\n (!(arguments.length === 2) && debug.assert(`You need to pass the model name and id to the store's find method`, arguments.length === 2));\n (!(typeof id === 'string' || typeof id === 'number') && debug.assert(`You cannot pass '${id}' as id to the store's find method`, typeof id === 'string' || typeof id === 'number'));\n (!(typeof id !== 'object') && debug.assert(`Calling store.find() with a query object is no longer supported. Use store.query() instead.`, typeof id !== 'object'));\n (!(typeof modelName === 'string') && debug.assert(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${modelName}`, typeof modelName === 'string'));\n return this.findRecord(modelName, id);\n }\n\n /**\n This method returns a record for a given identifier or type and id combination.\n The `findRecord` method will always resolve its promise with the same\n object for a given identifier or type and `id`.\n The `findRecord` method will always return a **promise** that will be\n resolved with the record.\n **Example 1**\n ```app/routes/post.js\n import Route from '@ember/routing/route';\n export default class PostRoute extends Route {\n model({ post_id }) {\n return this.store.findRecord('post', post_id);\n }\n }\n ```\n **Example 2**\n `findRecord` can be called with a single identifier argument instead of the combination\n of `type` (modelName) and `id` as separate arguments. You may recognize this combo as\n the typical pairing from [JSON:API](https://jsonapi.org/format/#document-resource-object-identification)\n ```app/routes/post.js\n import Route from '@ember/routing/route';\n export default class PostRoute extends Route {\n model({ post_id: id }) {\n return this.store.findRecord({ type: 'post', id });\n }\n }\n ```\n **Example 3**\n If you have previously received an lid via an Identifier for this record, and the record\n has already been assigned an id, you can find the record again using just the lid.\n ```app/routes/post.js\n store.findRecord({ lid });\n ```\n If the record is not yet available, the store will ask the adapter's `findRecord`\n method to retrieve and supply the necessary data. If the record is already present\n in the store, it depends on the reload behavior _when_ the returned promise\n resolves.\n ### Preloading\n You can optionally `preload` specific attributes and relationships that you know of\n by passing them via the passed `options`.\n For example, if your Ember route looks like `/posts/1/comments/2` and your API route\n for the comment also looks like `/posts/1/comments/2` if you want to fetch the comment\n without also fetching the post you can pass in the post to the `findRecord` call:\n ```app/routes/post-comments.js\n import Route from '@ember/routing/route';\n export default class PostRoute extends Route {\n model({ post_id, comment_id: id }) {\n return this.store.findRecord({ type: 'comment', id, { preload: { post: post_id }} });\n }\n }\n ```\n In your adapter you can then access this id without triggering a network request via the\n snapshot:\n ```app/adapters/application.js\n import EmberObject from '@ember/object';\n export default class Adapter extends EmberObject {\n findRecord(store, schema, id, snapshot) {\n let type = schema.modelName;\n if (type === 'comment')\n let postId = snapshot.belongsTo('post', { id: true });\n return fetch(`./posts/${postId}/comments/${id}`)\n .then(response => response.json())\n }\n }\n }\n ```\n This could also be achieved by supplying the post id to the adapter via the adapterOptions\n property on the options hash.\n ```app/routes/post-comments.js\n import Route from '@ember/routing/route';\n export default class PostRoute extends Route {\n model({ post_id, comment_id: id }) {\n return this.store.findRecord({ type: 'comment', id, { adapterOptions: { post: post_id }} });\n }\n }\n ```\n ```app/adapters/application.js\n import EmberObject from '@ember/object';\n export default class Adapter extends EmberObject {\n findRecord(store, schema, id, snapshot) {\n let type = schema.modelName;\n if (type === 'comment')\n let postId = snapshot.adapterOptions.post;\n return fetch(`./posts/${postId}/comments/${id}`)\n .then(response => response.json())\n }\n }\n }\n ```\n If you have access to the post model you can also pass the model itself to preload:\n ```javascript\n let post = await store.findRecord('post', 1);\n let comment = await store.findRecord('comment', 2, { post: myPostModel });\n ```\n ### Reloading\n The reload behavior is configured either via the passed `options` hash or\n the result of the adapter's `shouldReloadRecord`.\n If `{ reload: true }` is passed or `adapter.shouldReloadRecord` evaluates\n to `true`, then the returned promise resolves once the adapter returns\n data, regardless if the requested record is already in the store:\n ```js\n store.push({\n data: {\n id: 1,\n type: 'post',\n revision: 1\n }\n });\n // adapter#findRecord resolves with\n // [\n // {\n // id: 1,\n // type: 'post',\n // revision: 2\n // }\n // ]\n store.findRecord('post', 1, { reload: true }).then(function(post) {\n post.get('revision'); // 2\n });\n ```\n If no reload is indicated via the above mentioned ways, then the promise\n immediately resolves with the cached version in the store.\n ### Background Reloading\n Optionally, if `adapter.shouldBackgroundReloadRecord` evaluates to `true`,\n then a background reload is started, which updates the records' data, once\n it is available:\n ```js\n // app/adapters/post.js\n import ApplicationAdapter from \"./application\";\n export default class PostAdapter extends ApplicationAdapter {\n shouldReloadRecord(store, snapshot) {\n return false;\n },\n shouldBackgroundReloadRecord(store, snapshot) {\n return true;\n }\n });\n // ...\n store.push({\n data: {\n id: 1,\n type: 'post',\n revision: 1\n }\n });\n let blogPost = store.findRecord('post', 1).then(function(post) {\n post.get('revision'); // 1\n });\n // later, once adapter#findRecord resolved with\n // [\n // {\n // id: 1,\n // type: 'post',\n // revision: 2\n // }\n // ]\n blogPost.get('revision'); // 2\n ```\n If you would like to force or prevent background reloading, you can set a\n boolean value for `backgroundReload` in the options object for\n `findRecord`.\n ```app/routes/post/edit.js\n import Route from '@ember/routing/route';\n export default class PostEditRoute extends Route {\n model(params) {\n return this.store.findRecord('post', params.post_id, { backgroundReload: false });\n }\n }\n ```\n If you pass an object on the `adapterOptions` property of the options\n argument it will be passed to your adapter via the snapshot\n ```app/routes/post/edit.js\n import Route from '@ember/routing/route';\n export default class PostEditRoute extends Route {\n model(params) {\n return this.store.findRecord('post', params.post_id, {\n adapterOptions: { subscribe: false }\n });\n }\n }\n ```\n ```app/adapters/post.js\n import MyCustomAdapter from './custom-adapter';\n export default class PostAdapter extends MyCustomAdapter {\n findRecord(store, type, id, snapshot) {\n if (snapshot.adapterOptions.subscribe) {\n // ...\n }\n // ...\n }\n }\n ```\n See [peekRecord](../methods/peekRecord?anchor=peekRecord) to get the cached version of a record.\n ### Retrieving Related Model Records\n If you use an adapter such as Ember's default\n [`JSONAPIAdapter`](/ember-data/release/classes/JSONAPIAdapter)\n that supports the [JSON API specification](http://jsonapi.org/) and if your server\n endpoint supports the use of an\n ['include' query parameter](http://jsonapi.org/format/#fetching-includes),\n you can use `findRecord()` or `findAll()` to automatically retrieve additional records related to\n the one you request by supplying an `include` parameter in the `options` object.\n For example, given a `post` model that has a `hasMany` relationship with a `comment`\n model, when we retrieve a specific post we can have the server also return that post's\n comments in the same request:\n ```app/routes/post.js\n import Route from '@ember/routing/route';\n export default class PostRoute extends Route {\n model(params) {\n return this.store.findRecord('post', params.post_id, { include: 'comments' });\n }\n }\n ```\n ```app/adapters/application.js\n import EmberObject from '@ember/object';\n export default class Adapter extends EmberObject {\n findRecord(store, schema, id, snapshot) {\n let type = schema.modelName;\n if (type === 'post')\n let includes = snapshot.adapterOptions.include;\n return fetch(`./posts/${postId}?include=${includes}`)\n .then(response => response.json())\n }\n }\n }\n ```\n In this case, the post's comments would then be available in your template as\n `model.comments`.\n Multiple relationships can be requested using an `include` parameter consisting of a\n comma-separated list (without white-space) while nested relationships can be specified\n using a dot-separated sequence of relationship names. So to request both the post's\n comments and the authors of those comments the request would look like this:\n ```app/routes/post.js\n import Route from '@ember/routing/route';\n export default class PostRoute extends Route {\n model(params) {\n return this.store.findRecord('post', params.post_id, { include: 'comments,comments.author' });\n }\n }\n ```\n ### Retrieving Specific Fields by Type\n If your server endpoint supports the use of a ['fields' query parameter](https://jsonapi.org/format/#fetching-sparse-fieldsets),\n you can use pass those fields through to your server. At this point in time, this requires a few manual steps on your part.\n 1. Implement `buildQuery` in your adapter.\n ```app/adapters/application.js\n buildQuery(snapshot) {\n let query = super.buildQuery(...arguments);\n let { fields } = snapshot.adapterOptions;\n if (fields) {\n query.fields = fields;\n }\n return query;\n }\n ```\n 2. Then pass through the applicable fields to your `findRecord` request.\n Given a `post` model with attributes body, title, publishDate and meta, you can retrieve a filtered list of attributes.\n ```app/routes/post.js\n import Route from '@ember/routing/route';\n export default Route.extend({\n model(params) {\n return this.store.findRecord('post', params.post_id, { adapterOptions: { fields: { post: 'body,title' } });\n }\n });\n ```\n Moreover, you can filter attributes on related models as well. If a `post` has a `belongsTo` relationship to a user,\n just include the relationship key and attributes.\n ```app/routes/post.js\n import Route from '@ember/routing/route';\n export default Route.extend({\n model(params) {\n return this.store.findRecord('post', params.post_id, { adapterOptions: { fields: { post: 'body,title', user: 'name,email' } });\n }\n });\n ```\n @since 1.13.0\n @method findRecord\n @public\n @param {String|object} modelName - either a string representing the modelName or a ResourceIdentifier object containing both the type (a string) and the id (a string) for the record or an lid (a string) of an existing record\n @param {(String|Integer|Object)} id - optional object with options for the request only if the first param is a ResourceIdentifier, else the string id of the record to be retrieved\n @param {Object} [options] - if the first param is a string this will be the optional options for the request. See examples for available options.\n @return {Promise} promise\n */\n\n findRecord(resource, id, options) {\n {\n assertDestroyingStore$1(this, 'findRecord');\n }\n (!(utils.isPresent(resource)) && debug.assert(`You need to pass a modelName or resource identifier as the first argument to the store's findRecord method`, utils.isPresent(resource)));\n if (isMaybeIdentifier(resource)) {\n options = id;\n } else {\n (!(typeof resource === 'string') && debug.assert(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${resource}`, typeof resource === 'string'));\n const type = normalizeModelName(resource);\n const normalizedId = ensureStringId(id);\n resource = constructResource(type, normalizedId);\n }\n const internalModel = internalModelFactoryFor(this).lookup(resource);\n options = options || {};\n if (!internalModel.currentState.isLoaded) {\n return this._findByInternalModel(internalModel, options);\n }\n let fetchedInternalModel = this._findRecord(internalModel, options);\n return promiseRecord(fetchedInternalModel, `DS: Store#findRecord ${internalModel.identifier}`);\n }\n _findRecord(internalModel, options) {\n // Refetch if the reload option is passed\n if (options.reload) {\n return this._scheduleFetch(internalModel, options);\n }\n let snapshot = internalModel.createSnapshot(options);\n let adapter = this.adapterFor(internalModel.modelName);\n\n // Refetch the record if the adapter thinks the record is stale\n if (typeof options.reload === 'undefined' && adapter.shouldReloadRecord && adapter.shouldReloadRecord(this, snapshot)) {\n return this._scheduleFetch(internalModel, options);\n }\n if (options.backgroundReload === false) {\n return RSVP.Promise.resolve(internalModel);\n }\n\n // Trigger the background refetch if backgroundReload option is passed\n if (options.backgroundReload || !adapter.shouldBackgroundReloadRecord || adapter.shouldBackgroundReloadRecord(this, snapshot)) {\n this._scheduleFetch(internalModel, options);\n }\n\n // Return the cached record\n return RSVP.Promise.resolve(internalModel);\n }\n _findByInternalModel(internalModel, options = {}) {\n if (options.preload) {\n this._backburner.join(() => {\n internalModel.preloadData(options.preload);\n });\n }\n let fetchedInternalModel = this._findEmptyInternalModel(internalModel, options);\n return promiseRecord(fetchedInternalModel, `DS: Store#findRecord ${internalModel.modelName} with id: ${internalModel.id}`);\n }\n _findEmptyInternalModel(internalModel, options) {\n if (internalModel.currentState.isEmpty) {\n return this._scheduleFetch(internalModel, options);\n }\n if (internalModel.currentState.isLoading) {\n let pendingRequest = this._fetchManager.getPendingFetch(internalModel.identifier, options);\n if (pendingRequest) {\n return pendingRequest.then(() => RSVP.Promise.resolve(internalModel));\n }\n return this._scheduleFetch(internalModel, options);\n }\n return RSVP.Promise.resolve(internalModel);\n }\n\n /**\n This method makes a series of requests to the adapter's `find` method\n and returns a promise that resolves once they are all loaded.\n @private\n @method findByIds\n @param {String} modelName\n @param {Array} ids\n @return {Promise} promise\n */\n findByIds(modelName, ids) {\n {\n assertDestroyingStore$1(this, 'findByIds');\n }\n (!(utils.isPresent(modelName)) && debug.assert(`You need to pass a model name to the store's findByIds method`, utils.isPresent(modelName)));\n (!(typeof modelName === 'string') && debug.assert(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${modelName}`, typeof modelName === 'string'));\n let promises = new Array(ids.length);\n let normalizedModelName = normalizeModelName(modelName);\n for (let i = 0; i < ids.length; i++) {\n promises[i] = this.findRecord(normalizedModelName, ids[i]);\n }\n return promiseArray(RSVP.all(promises).then(EmberArray.A, null, `DS: Store#findByIds of ${normalizedModelName} complete`));\n }\n _scheduleFetchMany(internalModels, options) {\n let fetches = new Array(internalModels.length);\n for (let i = 0; i < internalModels.length; i++) {\n fetches[i] = this._scheduleFetch(internalModels[i], options);\n }\n return RSVP.Promise.all(fetches);\n }\n _scheduleFetch(internalModel, options = {}) {\n let generateStackTrace = this.generateStackTracesForTrackedRequests;\n // TODO remove this once we don't rely on state machine\n internalModel.send('loadingData');\n let identifier = internalModel.identifier;\n assertIdentifierHasId(identifier);\n let promise = this._fetchManager.scheduleFetch(identifier, options, generateStackTrace);\n return promise.then(payload => {\n // ensure that regardless of id returned we assign to the correct record\n if (payload.data && !Array.isArray(payload.data)) {\n payload.data.lid = identifier.lid;\n }\n\n // Returning this._push here, breaks typing but not any tests, investigate potential missing tests\n let potentiallyNewIm = this._push(payload);\n if (potentiallyNewIm && !Array.isArray(potentiallyNewIm)) {\n return potentiallyNewIm;\n } else {\n return internalModel;\n }\n }, error => {\n // TODO remove this once we don't rely on state machine\n internalModel.send('notFound');\n if (internalModel.currentState.isEmpty) {\n internalModel.unloadRecord();\n }\n throw error;\n });\n }\n\n /**\n Get the reference for the specified record.\n Example\n ```javascript\n let userRef = store.getReference('user', 1);\n // check if the user is loaded\n let isLoaded = userRef.value() !== null;\n // get the record of the reference (null if not yet available)\n let user = userRef.value();\n // get the identifier of the reference\n if (userRef.remoteType() === 'id') {\n let id = userRef.id();\n }\n // load user (via store.find)\n userRef.load().then(...)\n // or trigger a reload\n userRef.reload().then(...)\n // provide data for reference\n userRef.push({ id: 1, username: '@user' }).then(function(user) {\n userRef.value() === user;\n });\n ```\n @method getReference\n @public\n @param {String|object} resource - modelName (string) or Identifier (object)\n @param {String|Integer} id\n @since 2.5.0\n @return {RecordReference}\n */\n getReference(resource, id) {\n {\n assertDestroyingStore$1(this, 'getReference');\n }\n let resourceIdentifier;\n if (arguments.length === 1 && isMaybeIdentifier(resource)) {\n resourceIdentifier = resource;\n } else {\n const type = normalizeModelName(resource);\n const normalizedId = ensureStringId(id);\n resourceIdentifier = constructResource(type, normalizedId);\n }\n (!(isMaybeIdentifier(resourceIdentifier)) && debug.assert('getReference expected to receive either a resource identifier or type and id as arguments', isMaybeIdentifier(resourceIdentifier)));\n let identifier = this.identifierCache.getOrCreateRecordIdentifier(resourceIdentifier);\n if (identifier) {\n return RECORD_REFERENCES.lookup(identifier);\n }\n }\n\n /**\n Get a record by a given type and ID without triggering a fetch.\n This method will synchronously return the record if it is available in the store,\n otherwise it will return `null`. A record is available if it has been fetched earlier, or\n pushed manually into the store.\n See [findRecord](../methods/findRecord?anchor=findRecord) if you would like to request this record from the backend.\n _Note: This is a synchronous method and does not return a promise._\n **Example 1**\n ```js\n let post = store.peekRecord('post', 1);\n post.id; // 1\n ```\n `peekRecord` can be called with a single identifier argument instead of the combination\n of `type` (modelName) and `id` as separate arguments. You may recognize this combo as\n the typical pairing from [JSON:API](https://jsonapi.org/format/#document-resource-object-identification)\n **Example 2**\n ```js\n let post = store.peekRecord({ type: 'post', id });\n post.id; // 1\n ```\n If you have previously received an lid from an Identifier for this record, you can lookup the record again using\n just the lid.\n **Example 3**\n ```js\n let post = store.peekRecord({ lid });\n post.id; // 1\n ```\n @since 1.13.0\n @method peekRecord\n @public\n @param {String|object} modelName - either a string representing the modelName or a ResourceIdentifier object containing both the type (a string) and the id (a string) for the record or an lid (a string) of an existing record\n @param {String|Integer} id - optional only if the first param is a ResourceIdentifier, else the string id of the record to be retrieved.\n @return {Model|null} record\n */\n\n peekRecord(identifier, id) {\n if (arguments.length === 1 && isMaybeIdentifier(identifier)) {\n let stableIdentifier = this.identifierCache.peekRecordIdentifier(identifier);\n if (stableIdentifier) {\n return internalModelFactoryFor(this).peek(stableIdentifier)?.getRecord() || null;\n }\n return null;\n }\n {\n assertDestroyingStore$1(this, 'peekRecord');\n }\n (!(utils.isPresent(identifier)) && debug.assert(`You need to pass a model name to the store's peekRecord method`, utils.isPresent(identifier)));\n (!(typeof identifier === 'string') && debug.assert(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${identifier}`, typeof identifier === 'string'));\n const type = normalizeModelName(identifier);\n const normalizedId = ensureStringId(id);\n if (this.hasRecordForId(type, normalizedId)) {\n const resource = constructResource(type, normalizedId);\n return internalModelFactoryFor(this).lookup(resource).getRecord();\n } else {\n return null;\n }\n }\n\n /**\n This method is called by the record's `reload` method.\n This method calls the adapter's `find` method, which returns a promise. When\n **that** promise resolves, `_reloadRecord` will resolve the promise returned\n by the record's `reload`.\n @method _reloadRecord\n @private\n @param {Model} internalModel\n @param options optional to include adapterOptions\n @return {Promise} promise\n */\n _reloadRecord(internalModel, options) {\n options.isReloading = true;\n let {\n id,\n modelName\n } = internalModel;\n let adapter = this.adapterFor(modelName);\n (!(id) && debug.assert(`You cannot reload a record without an ID`, id));\n (!(adapter) && debug.assert(`You tried to reload a record but you have no adapter (for ${modelName})`, adapter));\n (!(typeof adapter.findRecord === 'function' || typeof adapter.find === 'function') && debug.assert(`You tried to reload a record but your adapter does not implement 'findRecord'`, typeof adapter.findRecord === 'function' || typeof adapter.find === 'function'));\n return this._scheduleFetch(internalModel, options);\n }\n\n /**\n This method returns true if a record for a given modelName and id is already\n loaded in the store. Use this function to know beforehand if a findRecord()\n will result in a request or that it will be a cache hit.\n Example\n ```javascript\n store.hasRecordForId('post', 1); // false\n store.findRecord('post', 1).then(function() {\n store.hasRecordForId('post', 1); // true\n });\n ```\n @method hasRecordForId\n @public\n @param {String} modelName\n @param {(String|Integer)} id\n @return {Boolean}\n */\n hasRecordForId(modelName, id) {\n {\n assertDestroyingStore$1(this, 'hasRecordForId');\n }\n (!(utils.isPresent(modelName)) && debug.assert(`You need to pass a model name to the store's hasRecordForId method`, utils.isPresent(modelName)));\n (!(typeof modelName === 'string') && debug.assert(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${modelName}`, typeof modelName === 'string'));\n const type = normalizeModelName(modelName);\n const trueId = ensureStringId(id);\n const resource = {\n type,\n id: trueId\n };\n const identifier = this.identifierCache.peekRecordIdentifier(resource);\n const internalModel = identifier && internalModelFactoryFor(this).peek(identifier);\n return !!internalModel && internalModel.currentState.isLoaded;\n }\n\n /**\n Returns id record for a given type and ID. If one isn't already loaded,\n it builds a new record and leaves it in the `empty` state.\n @method recordForId\n @private\n @param {String} modelName\n @param {(String|Integer)} id\n @return {Model} record\n */\n recordForId(modelName, id) {\n {\n assertDestroyingStore$1(this, 'recordForId');\n }\n (!(utils.isPresent(modelName)) && debug.assert(`You need to pass a model name to the store's recordForId method`, utils.isPresent(modelName)));\n (!(typeof modelName === 'string') && debug.assert(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${modelName}`, typeof modelName === 'string'));\n const resource = constructResource(modelName, ensureStringId(id));\n return internalModelFactoryFor(this).lookup(resource).getRecord();\n }\n\n /**\n @method findMany\n @private\n @param {Array} internalModels\n @return {Promise} promise\n */\n findMany(internalModels, options) {\n {\n assertDestroyingStore$1(this, 'findMany');\n }\n let finds = new Array(internalModels.length);\n for (let i = 0; i < internalModels.length; i++) {\n finds[i] = this._findEmptyInternalModel(internalModels[i], options);\n }\n return RSVP.Promise.all(finds);\n }\n\n /**\n If a relationship was originally populated by the adapter as a link\n (as opposed to a list of IDs), this method is called when the\n relationship is fetched.\n The link (which is usually a URL) is passed through unchanged, so the\n adapter can make whatever request it wants.\n The usual use-case is for the server to register a URL as a link, and\n then use that URL in the future to make a request for the relationship.\n @method findHasMany\n @private\n @param {InternalModel} internalModel\n @param {any} link\n @param {(Relationship)} relationship\n @return {Promise} promise\n */\n findHasMany(internalModel, link, relationship, options) {\n {\n assertDestroyingStore$1(this, 'findHasMany');\n }\n let adapter = this.adapterFor(internalModel.modelName);\n (!(adapter) && debug.assert(`You tried to load a hasMany relationship but you have no adapter (for ${internalModel.modelName})`, adapter));\n (!(typeof adapter.findHasMany === 'function') && debug.assert(`You tried to load a hasMany relationship from a specified 'link' in the original payload but your adapter does not implement 'findHasMany'`, typeof adapter.findHasMany === 'function'));\n return _findHasMany(adapter, this, internalModel, link, relationship, options);\n }\n _findHasManyByJsonApiResource(resource, parentInternalModel, relationship, options) {\n {\n if (!resource) {\n return RSVP.resolve([]);\n }\n const {\n definition,\n state\n } = relationship;\n let adapter = this.adapterFor(definition.type);\n let {\n isStale,\n hasDematerializedInverse,\n hasReceivedData,\n isEmpty,\n shouldForceReload\n } = state;\n const allInverseRecordsAreLoaded = areAllInverseRecordsLoaded(this, resource);\n let shouldFindViaLink = resource.links && resource.links.related && (typeof adapter.findHasMany === 'function' || typeof resource.data === 'undefined') && (shouldForceReload || hasDematerializedInverse || isStale || !allInverseRecordsAreLoaded && !isEmpty);\n\n // fetch via link\n if (shouldFindViaLink) {\n // findHasMany, although not public, does not need to care about our upgrade relationship definitions\n // and can stick with the public definition API for now.\n const relationshipMeta = this._storeWrapper.relationshipsDefinitionFor(definition.inverseType)[definition.key];\n return this.findHasMany(parentInternalModel, resource.links.related, relationshipMeta, options);\n }\n let preferLocalCache = hasReceivedData && !isEmpty;\n let hasLocalPartialData = hasDematerializedInverse || isEmpty && Array.isArray(resource.data) && resource.data.length > 0;\n\n // fetch using data, pulling from local cache if possible\n if (!shouldForceReload && !isStale && (preferLocalCache || hasLocalPartialData)) {\n let internalModels = resource.data.map(json => this._internalModelForResource(json));\n return this.findMany(internalModels, options);\n }\n let hasData = hasReceivedData && !isEmpty;\n\n // fetch by data\n if (hasData || hasLocalPartialData) {\n let internalModels = resource.data.map(json => this._internalModelForResource(json));\n return this._scheduleFetchMany(internalModels, options);\n }\n\n // we were explicitly told we have no data and no links.\n // TODO if the relationshipIsStale, should we hit the adapter anyway?\n return RSVP.resolve([]);\n }\n }\n\n /**\n @method findBelongsTo\n @private\n @param {InternalModel} internalModel\n @param {any} link\n @param {Relationship} relationship\n @return {Promise} promise\n */\n findBelongsTo(internalModel, link, relationship, options) {\n {\n assertDestroyingStore$1(this, 'findBelongsTo');\n }\n let adapter = this.adapterFor(internalModel.modelName);\n (!(adapter) && debug.assert(`You tried to load a belongsTo relationship but you have no adapter (for ${internalModel.modelName})`, adapter));\n (!(typeof adapter.findBelongsTo === 'function') && debug.assert(`You tried to load a belongsTo relationship from a specified 'link' in the original payload but your adapter does not implement 'findBelongsTo'`, typeof adapter.findBelongsTo === 'function'));\n return _findBelongsTo(adapter, this, internalModel, link, relationship, options);\n }\n _fetchBelongsToLinkFromResource(resource, parentInternalModel, relationshipMeta, options) {\n if (!resource || !resource.links || !resource.links.related) {\n // should we warn here, not sure cause its an internal method\n return RSVP.resolve(null);\n }\n return this.findBelongsTo(parentInternalModel, resource.links.related, relationshipMeta, options).then(internalModel => {\n return internalModel ? internalModel.getRecord() : null;\n });\n }\n _findBelongsToByJsonApiResource(resource, parentInternalModel, relationshipMeta, options) {\n if (!resource) {\n return RSVP.resolve(null);\n }\n const internalModel = resource.data ? this._internalModelForResource(resource.data) : null;\n let {\n isStale,\n hasDematerializedInverse,\n hasReceivedData,\n isEmpty,\n shouldForceReload\n } = resource._relationship.state;\n const allInverseRecordsAreLoaded = areAllInverseRecordsLoaded(this, resource);\n let shouldFindViaLink = resource.links && resource.links.related && (shouldForceReload || hasDematerializedInverse || isStale || !allInverseRecordsAreLoaded && !isEmpty);\n if (internalModel) {\n // short circuit if we are already loading\n let pendingRequest = this._fetchManager.getPendingFetch(internalModel.identifier, options);\n if (pendingRequest) {\n return pendingRequest.then(() => internalModel.getRecord());\n }\n }\n\n // fetch via link\n if (shouldFindViaLink) {\n return this._fetchBelongsToLinkFromResource(resource, parentInternalModel, relationshipMeta, options);\n }\n let preferLocalCache = hasReceivedData && allInverseRecordsAreLoaded && !isEmpty;\n let hasLocalPartialData = hasDematerializedInverse || isEmpty && resource.data;\n // null is explicit empty, undefined is \"we don't know anything\"\n let localDataIsEmpty = resource.data === undefined || resource.data === null;\n\n // fetch using data, pulling from local cache if possible\n if (!shouldForceReload && !isStale && (preferLocalCache || hasLocalPartialData)) {\n /*\n We have canonical data, but our local state is empty\n */\n if (localDataIsEmpty) {\n return RSVP.resolve(null);\n }\n if (!internalModel) {\n (!(internalModel) && debug.assert(`No InternalModel found for ${resource.lid}`, internalModel));\n }\n return this._findByInternalModel(internalModel, options);\n }\n let resourceIsLocal = !localDataIsEmpty && resource.data.id === null;\n if (internalModel && resourceIsLocal) {\n return RSVP.resolve(internalModel.getRecord());\n }\n\n // fetch by data\n if (internalModel && !localDataIsEmpty) {\n return this._scheduleFetch(internalModel, options).then(() => {\n return internalModel.getRecord();\n });\n }\n\n // we were explicitly told we have no data and no links.\n // TODO if the relationshipIsStale, should we hit the adapter anyway?\n return RSVP.resolve(null);\n }\n\n /**\n This method delegates a query to the adapter. This is the one place where\n adapter-level semantics are exposed to the application.\n Each time this method is called a new request is made through the adapter.\n Exposing queries this way seems preferable to creating an abstract query\n language for all server-side queries, and then require all adapters to\n implement them.\n ---\n If you do something like this:\n ```javascript\n store.query('person', { page: 1 });\n ```\n The request made to the server will look something like this:\n ```\n GET \"/api/v1/person?page=1\"\n ```\n ---\n If you do something like this:\n ```javascript\n store.query('person', { ids: [1, 2, 3] });\n ```\n The request made to the server will look something like this:\n ```\n GET \"/api/v1/person?ids%5B%5D=1&ids%5B%5D=2&ids%5B%5D=3\"\n decoded: \"/api/v1/person?ids[]=1&ids[]=2&ids[]=3\"\n ```\n This method returns a promise, which is resolved with an\n [`AdapterPopulatedRecordArray`](/ember-data/release/classes/AdapterPopulatedRecordArray)\n once the server returns.\n @since 1.13.0\n @method query\n @public\n @param {String} modelName\n @param {any} query an opaque query to be used by the adapter\n @param {Object} options optional, may include `adapterOptions` hash which will be passed to adapter.query\n @return {Promise} promise\n */\n query(modelName, query, options) {\n {\n assertDestroyingStore$1(this, 'query');\n }\n (!(utils.isPresent(modelName)) && debug.assert(`You need to pass a model name to the store's query method`, utils.isPresent(modelName)));\n (!(query) && debug.assert(`You need to pass a query hash to the store's query method`, query));\n (!(typeof modelName === 'string') && debug.assert(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${modelName}`, typeof modelName === 'string'));\n let adapterOptionsWrapper = {};\n if (options && options.adapterOptions) {\n adapterOptionsWrapper.adapterOptions = options.adapterOptions;\n }\n let normalizedModelName = normalizeModelName(modelName);\n return this._query(normalizedModelName, query, null, adapterOptionsWrapper);\n }\n _query(modelName, query, array, options) {\n (!(utils.isPresent(modelName)) && debug.assert(`You need to pass a model name to the store's query method`, utils.isPresent(modelName)));\n (!(query) && debug.assert(`You need to pass a query hash to the store's query method`, query));\n (!(typeof modelName === 'string') && debug.assert(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${modelName}`, typeof modelName === 'string'));\n let adapter = this.adapterFor(modelName);\n (!(adapter) && debug.assert(`You tried to load a query but you have no adapter (for ${modelName})`, adapter));\n (!(typeof adapter.query === 'function') && debug.assert(`You tried to load a query but your adapter does not implement 'query'`, typeof adapter.query === 'function'));\n return promiseArray(_query(adapter, this, modelName, query, array, options));\n }\n\n /**\n This method makes a request for one record, where the `id` is not known\n beforehand (if the `id` is known, use [`findRecord`](../methods/findRecord?anchor=findRecord)\n instead).\n This method can be used when it is certain that the server will return a\n single object for the primary data.\n Each time this method is called a new request is made through the adapter.\n Let's assume our API provides an endpoint for the currently logged in user\n via:\n ```\n // GET /api/current_user\n {\n user: {\n id: 1234,\n username: 'admin'\n }\n }\n ```\n Since the specific `id` of the `user` is not known beforehand, we can use\n `queryRecord` to get the user:\n ```javascript\n store.queryRecord('user', {}).then(function(user) {\n let username = user.get('username');\n console.log(`Currently logged in as ${username}`);\n });\n ```\n The request is made through the adapters' `queryRecord`:\n ```app/adapters/user.js\n import Adapter from '@ember-data/adapter';\n import $ from 'jquery';\n export default class UserAdapter extends Adapter {\n queryRecord(modelName, query) {\n return $.getJSON('/api/current_user');\n }\n }\n ```\n Note: the primary use case for `store.queryRecord` is when a single record\n is queried and the `id` is not known beforehand. In all other cases\n `store.query` and using the first item of the array is likely the preferred\n way:\n ```\n // GET /users?username=unique\n {\n data: [{\n id: 1234,\n type: 'user',\n attributes: {\n username: \"unique\"\n }\n }]\n }\n ```\n ```javascript\n store.query('user', { username: 'unique' }).then(function(users) {\n return users.get('firstObject');\n }).then(function(user) {\n let id = user.get('id');\n });\n ```\n This method returns a promise, which resolves with the found record.\n If the adapter returns no data for the primary data of the payload, then\n `queryRecord` resolves with `null`:\n ```\n // GET /users?username=unique\n {\n data: null\n }\n ```\n ```javascript\n store.queryRecord('user', { username: 'unique' }).then(function(user) {\n console.log(user); // null\n });\n ```\n @since 1.13.0\n @method queryRecord\n @public\n @param {String} modelName\n @param {any} query an opaque query to be used by the adapter\n @param {Object} options optional, may include `adapterOptions` hash which will be passed to adapter.queryRecord\n @return {Promise} promise which resolves with the found record or `null`\n */\n queryRecord(modelName, query, options) {\n {\n assertDestroyingStore$1(this, 'queryRecord');\n }\n (!(utils.isPresent(modelName)) && debug.assert(`You need to pass a model name to the store's queryRecord method`, utils.isPresent(modelName)));\n (!(query) && debug.assert(`You need to pass a query hash to the store's queryRecord method`, query));\n (!(typeof modelName === 'string') && debug.assert(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${modelName}`, typeof modelName === 'string'));\n let normalizedModelName = normalizeModelName(modelName);\n let adapter = this.adapterFor(normalizedModelName);\n let adapterOptionsWrapper = {};\n if (options && options.adapterOptions) {\n adapterOptionsWrapper.adapterOptions = options.adapterOptions;\n }\n (!(adapter) && debug.assert(`You tried to make a query but you have no adapter (for ${normalizedModelName})`, adapter));\n (!(typeof adapter.queryRecord === 'function') && debug.assert(`You tried to make a query but your adapter does not implement 'queryRecord'`, typeof adapter.queryRecord === 'function'));\n return promiseObject(_queryRecord(adapter, this, normalizedModelName, query, adapterOptionsWrapper).then(internalModel => {\n // the promise returned by store.queryRecord is expected to resolve with\n // an instance of Model\n if (internalModel) {\n return internalModel.getRecord();\n }\n return null;\n }));\n }\n\n /**\n `findAll` asks the adapter's `findAll` method to find the records for the\n given type, and returns a promise which will resolve with all records of\n this type present in the store, even if the adapter only returns a subset\n of them.\n ```app/routes/authors.js\n import Route from '@ember/routing/route';\n export default class AuthorsRoute extends Route {\n model(params) {\n return this.store.findAll('author');\n }\n }\n ```\n _When_ the returned promise resolves depends on the reload behavior,\n configured via the passed `options` hash and the result of the adapter's\n `shouldReloadAll` method.\n ### Reloading\n If `{ reload: true }` is passed or `adapter.shouldReloadAll` evaluates to\n `true`, then the returned promise resolves once the adapter returns data,\n regardless if there are already records in the store:\n ```js\n store.push({\n data: {\n id: 'first',\n type: 'author'\n }\n });\n // adapter#findAll resolves with\n // [\n // {\n // id: 'second',\n // type: 'author'\n // }\n // ]\n store.findAll('author', { reload: true }).then(function(authors) {\n authors.getEach('id'); // ['first', 'second']\n });\n ```\n If no reload is indicated via the above mentioned ways, then the promise\n immediately resolves with all the records currently loaded in the store.\n ### Background Reloading\n Optionally, if `adapter.shouldBackgroundReloadAll` evaluates to `true`,\n then a background reload is started. Once this resolves, the array with\n which the promise resolves, is updated automatically so it contains all the\n records in the store:\n ```app/adapters/application.js\n import Adapter from '@ember-data/adapter';\n export default class ApplicationAdapter extends Adapter {\n shouldReloadAll(store, snapshotsArray) {\n return false;\n },\n shouldBackgroundReloadAll(store, snapshotsArray) {\n return true;\n }\n });\n // ...\n store.push({\n data: {\n id: 'first',\n type: 'author'\n }\n });\n let allAuthors;\n store.findAll('author').then(function(authors) {\n authors.getEach('id'); // ['first']\n allAuthors = authors;\n });\n // later, once adapter#findAll resolved with\n // [\n // {\n // id: 'second',\n // type: 'author'\n // }\n // ]\n allAuthors.getEach('id'); // ['first', 'second']\n ```\n If you would like to force or prevent background reloading, you can set a\n boolean value for `backgroundReload` in the options object for\n `findAll`.\n ```app/routes/post/edit.js\n import Route from '@ember/routing/route';\n export default class PostEditRoute extends Route {\n model() {\n return this.store.findAll('post', { backgroundReload: false });\n }\n }\n ```\n If you pass an object on the `adapterOptions` property of the options\n argument it will be passed to you adapter via the `snapshotRecordArray`\n ```app/routes/posts.js\n import Route from '@ember/routing/route';\n export default class PostsRoute extends Route {\n model(params) {\n return this.store.findAll('post', {\n adapterOptions: { subscribe: false }\n });\n }\n }\n ```\n ```app/adapters/post.js\n import MyCustomAdapter from './custom-adapter';\n export default class UserAdapter extends MyCustomAdapter {\n findAll(store, type, sinceToken, snapshotRecordArray) {\n if (snapshotRecordArray.adapterOptions.subscribe) {\n // ...\n }\n // ...\n }\n }\n ```\n See [peekAll](../methods/peekAll?anchor=peekAll) to get an array of current records in the\n store, without waiting until a reload is finished.\n ### Retrieving Related Model Records\n If you use an adapter such as Ember's default\n [`JSONAPIAdapter`](/ember-data/release/classes/JSONAPIAdapter)\n that supports the [JSON API specification](http://jsonapi.org/) and if your server\n endpoint supports the use of an\n ['include' query parameter](http://jsonapi.org/format/#fetching-includes),\n you can use `findAll()` to automatically retrieve additional records related to\n those requested by supplying an `include` parameter in the `options` object.\n For example, given a `post` model that has a `hasMany` relationship with a `comment`\n model, when we retrieve all of the post records we can have the server also return\n all of the posts' comments in the same request:\n ```app/routes/posts.js\n import Route from '@ember/routing/route';\n export default class PostsRoute extends Route {\n model() {\n return this.store.findAll('post', { include: 'comments' });\n }\n }\n ```\n Multiple relationships can be requested using an `include` parameter consisting of a\n comma-separated list (without white-space) while nested relationships can be specified\n using a dot-separated sequence of relationship names. So to request both the posts'\n comments and the authors of those comments the request would look like this:\n ```app/routes/posts.js\n import Route from '@ember/routing/route';\n export default class PostsRoute extends Route {\n model() {\n return this.store.findAll('post', { include: 'comments,comments.author' });\n }\n }\n ```\n See [query](../methods/query?anchor=query) to only get a subset of records from the server.\n @since 1.13.0\n @method findAll\n @public\n @param {String} modelName\n @param {Object} options\n @return {Promise} promise\n */\n findAll(modelName, options) {\n {\n assertDestroyingStore$1(this, 'findAll');\n }\n (!(utils.isPresent(modelName)) && debug.assert(`You need to pass a model name to the store's findAll method`, utils.isPresent(modelName)));\n (!(typeof modelName === 'string') && debug.assert(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${modelName}`, typeof modelName === 'string'));\n let normalizedModelName = normalizeModelName(modelName);\n let fetch = this._fetchAll(normalizedModelName, this.peekAll(normalizedModelName), options);\n return fetch;\n }\n\n /**\n @method _fetchAll\n @private\n @param {Model} modelName\n @param {RecordArray} array\n @return {Promise} promise\n */\n _fetchAll(modelName, array, options = {}) {\n let adapter = this.adapterFor(modelName);\n (!(adapter) && debug.assert(`You tried to load all records but you have no adapter (for ${modelName})`, adapter));\n (!(typeof adapter.findAll === 'function') && debug.assert(`You tried to load all records but your adapter does not implement 'findAll'`, typeof adapter.findAll === 'function'));\n if (options.reload) {\n object.set(array, 'isUpdating', true);\n return promiseArray(_findAll(adapter, this, modelName, options));\n }\n let snapshotArray = array._createSnapshot(options);\n if (options.reload !== false) {\n if (adapter.shouldReloadAll && adapter.shouldReloadAll(this, snapshotArray) || !adapter.shouldReloadAll && snapshotArray.length === 0) {\n object.set(array, 'isUpdating', true);\n return promiseArray(_findAll(adapter, this, modelName, options));\n }\n }\n if (options.backgroundReload === false) {\n return promiseArray(RSVP.Promise.resolve(array));\n }\n if (options.backgroundReload || !adapter.shouldBackgroundReloadAll || adapter.shouldBackgroundReloadAll(this, snapshotArray)) {\n object.set(array, 'isUpdating', true);\n _findAll(adapter, this, modelName, options);\n }\n return promiseArray(RSVP.Promise.resolve(array));\n }\n\n /**\n @method _didUpdateAll\n @param {String} modelName\n @private\n */\n _didUpdateAll(modelName) {\n this.recordArrayManager._didUpdateAll(modelName);\n }\n\n /**\n This method returns a filtered array that contains all of the\n known records for a given type in the store.\n Note that because it's just a filter, the result will contain any\n locally created records of the type, however, it will not make a\n request to the backend to retrieve additional records. If you\n would like to request all the records from the backend please use\n [store.findAll](../methods/findAll?anchor=findAll).\n Also note that multiple calls to `peekAll` for a given type will always\n return the same `RecordArray`.\n Example\n ```javascript\n let localPosts = store.peekAll('post');\n ```\n @since 1.13.0\n @method peekAll\n @public\n @param {String} modelName\n @return {RecordArray}\n */\n peekAll(modelName) {\n {\n assertDestroyingStore$1(this, 'peekAll');\n }\n (!(utils.isPresent(modelName)) && debug.assert(`You need to pass a model name to the store's peekAll method`, utils.isPresent(modelName)));\n (!(typeof modelName === 'string') && debug.assert(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${modelName}`, typeof modelName === 'string'));\n let normalizedModelName = normalizeModelName(modelName);\n return this.recordArrayManager.liveRecordArrayFor(normalizedModelName);\n }\n\n /**\n This method unloads all records in the store.\n It schedules unloading to happen during the next run loop.\n Optionally you can pass a type which unload all records for a given type.\n ```javascript\n store.unloadAll();\n store.unloadAll('post');\n ```\n @method unloadAll\n @public\n @param {String} modelName\n */\n unloadAll(modelName) {\n {\n assertDestroyedStoreOnly$1(this, 'unloadAll');\n }\n (!(!modelName || typeof modelName === 'string') && debug.assert(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${modelName}`, !modelName || typeof modelName === 'string'));\n const factory = internalModelFactoryFor(this);\n if (modelName === undefined) {\n factory.clear();\n } else {\n let normalizedModelName = normalizeModelName(modelName);\n factory.clear(normalizedModelName);\n }\n }\n filter() {\n (debug.assert('The filter API has been moved to a plugin. To enable store.filter using an environment flag, or to use an alternative, you can visit the ember-data-filter addon page. https://github.com/ember-data/ember-data-filter', false));\n }\n\n // ..............\n // . PERSISTING .\n // ..............\n\n /**\n This method is called by `record.save`, and gets passed a\n resolver for the promise that `record.save` returns.\n It schedules saving to happen at the end of the run loop.\n @method scheduleSave\n @private\n @param {InternalModel} internalModel\n @param {Resolver} resolver\n @param {Object} options\n */\n scheduleSave(internalModel, resolver, options) {\n if (internalModel._isRecordFullyDeleted()) {\n resolver.resolve();\n return resolver.promise;\n }\n internalModel.adapterWillCommit();\n if (!options) {\n options = {};\n }\n let recordData = internalModel._recordData;\n let operation = 'updateRecord';\n\n // TODO handle missing isNew\n if (recordData.isNew && recordData.isNew()) {\n operation = 'createRecord';\n } else if (recordData.isDeleted && recordData.isDeleted()) {\n operation = 'deleteRecord';\n }\n options[SaveOp] = operation;\n let fetchManagerPromise = this._fetchManager.scheduleSave(internalModel.identifier, options);\n let promise = fetchManagerPromise.then(payload => {\n /*\n Note to future spelunkers hoping to optimize.\n We rely on this `run` to create a run loop if needed\n that `store._push` and `store.didSaveRecord` will both share.\n We use `join` because it is often the case that we\n have an outer run loop available still from the first\n call to `store._push`;\n */\n this._backburner.join(() => {\n let data = payload && payload.data;\n this.didSaveRecord(internalModel, {\n data\n }, operation);\n if (payload && payload.included) {\n this._push({\n data: null,\n included: payload.included\n });\n }\n });\n }, e => {\n if (typeof e === 'string') {\n throw e;\n }\n const {\n error,\n parsedErrors\n } = e;\n this.recordWasInvalid(internalModel, parsedErrors, error);\n throw error;\n });\n return promise;\n }\n\n /**\n This method is called at the end of the run loop, and\n flushes any records passed into `scheduleSave`\n @method flushPendingSave\n @private\n */\n flushPendingSave() {\n // assert here\n return;\n }\n\n /**\n This method is called once the promise returned by an\n adapter's `createRecord`, `updateRecord` or `deleteRecord`\n is resolved.\n If the data provides a server-generated ID, it will\n update the record and the store's indexes.\n @method didSaveRecord\n @private\n @param {InternalModel} internalModel the in-flight internal model\n @param {Object} data optional data (see above)\n @param {string} op the adapter operation that was committed\n */\n didSaveRecord(internalModel, dataArg, op) {\n {\n assertDestroyingStore$1(this, 'didSaveRecord');\n }\n let data;\n if (dataArg) {\n data = dataArg.data;\n }\n if (!data) {\n (!(internalModel.id) && debug.assert(`Your ${internalModel.modelName} record was saved to the server, but the response does not have an id and no id has been set client side. Records must have ids. Please update the server response to provide an id in the response or generate the id on the client side either before saving the record or while normalizing the response.`, internalModel.id));\n }\n const cache = this.identifierCache;\n const identifier = internalModel.identifier;\n if (op !== 'deleteRecord' && data) {\n cache.updateRecordIdentifier(identifier, data);\n }\n\n //We first make sure the primary data has been updated\n //TODO try to move notification to the user to the end of the runloop\n internalModel.adapterDidCommit(data);\n }\n\n /**\n This method is called once the promise returned by an\n adapter's `createRecord`, `updateRecord` or `deleteRecord`\n is rejected with a `InvalidError`.\n @method recordWasInvalid\n @private\n @param {InternalModel} internalModel\n @param {Object} errors\n */\n recordWasInvalid(internalModel, parsedErrors, error) {\n {\n assertDestroyingStore$1(this, 'recordWasInvalid');\n }\n internalModel.adapterDidInvalidate(parsedErrors, error);\n }\n\n /**\n This method is called once the promise returned by an\n adapter's `createRecord`, `updateRecord` or `deleteRecord`\n is rejected (with anything other than a `InvalidError`).\n @method recordWasError\n @private\n @param {InternalModel} internalModel\n @param {Error} error\n */\n recordWasError(internalModel, error) {\n {\n assertDestroyingStore$1(this, 'recordWasError');\n }\n internalModel.adapterDidError(error);\n }\n\n /**\n Sets newly received ID from the adapter's `createRecord`, `updateRecord`\n or `deleteRecord`.\n @method setRecordId\n @private\n @param {String} modelName\n @param {string} newId\n @param {string} clientId\n */\n setRecordId(modelName, newId, clientId) {\n {\n assertDestroyingStore$1(this, 'setRecordId');\n }\n internalModelFactoryFor(this).setRecordId(modelName, newId, clientId);\n }\n\n // ................\n // . LOADING DATA .\n // ................\n\n /**\n This internal method is used by `push`.\n @method _load\n @private\n @param {Object} data\n */\n _load(data) {\n const resource = constructResource(normalizeModelName(data.type), ensureStringId(data.id), coerceId(data.lid));\n let internalModel = internalModelFactoryFor(this).lookup(resource, data);\n\n // store.push will be from empty\n // findRecord will be from root.loading\n // all else will be updates\n const isLoading = internalModel.currentState.stateName === 'root.loading';\n const isUpdate = internalModel.currentState.isEmpty === false && !isLoading;\n\n // exclude store.push (root.empty) case\n let identifier = internalModel.identifier;\n if (isUpdate || isLoading) {\n let updatedIdentifier = this.identifierCache.updateRecordIdentifier(identifier, data);\n if (updatedIdentifier !== identifier) {\n // we encountered a merge of identifiers in which\n // two identifiers (and likely two internalModels)\n // existed for the same resource. Now that we have\n // determined the correct identifier to use, make sure\n // that we also use the correct internalModel.\n identifier = updatedIdentifier;\n internalModel = internalModelFactoryFor(this).lookup(identifier);\n }\n }\n internalModel.setupData(data);\n if (!isUpdate) {\n this.recordArrayManager.recordDidChange(identifier);\n }\n return internalModel;\n }\n\n /**\n Push some data for a given type into the store.\n This method expects normalized [JSON API](http://jsonapi.org/) document. This means you have to follow [JSON API specification](http://jsonapi.org/format/) with few minor adjustments:\n - record's `type` should always be in singular, dasherized form\n - members (properties) should be camelCased\n [Your primary data should be wrapped inside `data` property](http://jsonapi.org/format/#document-top-level):\n ```js\n store.push({\n data: {\n // primary data for single record of type `Person`\n id: '1',\n type: 'person',\n attributes: {\n firstName: 'Daniel',\n lastName: 'Kmak'\n }\n }\n });\n ```\n [Demo.](http://ember-twiddle.com/fb99f18cd3b4d3e2a4c7)\n `data` property can also hold an array (of records):\n ```js\n store.push({\n data: [\n // an array of records\n {\n id: '1',\n type: 'person',\n attributes: {\n firstName: 'Daniel',\n lastName: 'Kmak'\n }\n },\n {\n id: '2',\n type: 'person',\n attributes: {\n firstName: 'Tom',\n lastName: 'Dale'\n }\n }\n ]\n });\n ```\n [Demo.](http://ember-twiddle.com/69cdbeaa3702159dc355)\n There are some typical properties for `JSONAPI` payload:\n * `id` - mandatory, unique record's key\n * `type` - mandatory string which matches `model`'s dasherized name in singular form\n * `attributes` - object which holds data for record attributes - `attr`'s declared in model\n * `relationships` - object which must contain any of the following properties under each relationships' respective key (example path is `relationships.achievements.data`):\n - [`links`](http://jsonapi.org/format/#document-links)\n - [`data`](http://jsonapi.org/format/#document-resource-object-linkage) - place for primary data\n - [`meta`](http://jsonapi.org/format/#document-meta) - object which contains meta-information about relationship\n For this model:\n ```app/models/person.js\n import Model, { attr, hasMany } from '@ember-data/model';\n export default class PersonRoute extends Route {\n @attr('string') firstName;\n @attr('string') lastName;\n @hasMany('person') children;\n }\n ```\n To represent the children as IDs:\n ```js\n {\n data: {\n id: '1',\n type: 'person',\n attributes: {\n firstName: 'Tom',\n lastName: 'Dale'\n },\n relationships: {\n children: {\n data: [\n {\n id: '2',\n type: 'person'\n },\n {\n id: '3',\n type: 'person'\n },\n {\n id: '4',\n type: 'person'\n }\n ]\n }\n }\n }\n }\n ```\n [Demo.](http://ember-twiddle.com/343e1735e034091f5bde)\n To represent the children relationship as a URL:\n ```js\n {\n data: {\n id: '1',\n type: 'person',\n attributes: {\n firstName: 'Tom',\n lastName: 'Dale'\n },\n relationships: {\n children: {\n links: {\n related: '/people/1/children'\n }\n }\n }\n }\n }\n ```\n If you're streaming data or implementing an adapter, make sure\n that you have converted the incoming data into this form. The\n store's [normalize](../methods/normalize?anchor=normalize) method is a convenience\n helper for converting a json payload into the form Ember Data\n expects.\n ```js\n store.push(store.normalize('person', data));\n ```\n This method can be used both to push in brand new\n records, as well as to update existing records.\n @method push\n @public\n @param {Object} data\n @return the record(s) that was created or\n updated.\n */\n\n push(data) {\n {\n assertDestroyingStore$1(this, 'push');\n }\n let pushed = this._push(data);\n if (Array.isArray(pushed)) {\n let records = pushed.map(internalModel => internalModel.getRecord());\n return records;\n }\n if (pushed === null) {\n return null;\n }\n let record = pushed.getRecord();\n return record;\n }\n\n /**\n Push some data in the form of a json-api document into the store,\n without creating materialized records.\n @method _push\n @private\n @param {Object} jsonApiDoc\n @return {InternalModel|Array} pushed InternalModel(s)\n */\n _push(jsonApiDoc) {\n {\n assertDestroyingStore$1(this, '_push');\n }\n let internalModelOrModels = this._backburner.join(() => {\n let included = jsonApiDoc.included;\n let i, length;\n if (included) {\n for (i = 0, length = included.length; i < length; i++) {\n this._pushInternalModel(included[i]);\n }\n }\n if (Array.isArray(jsonApiDoc.data)) {\n length = jsonApiDoc.data.length;\n let internalModels = new Array(length);\n for (i = 0; i < length; i++) {\n internalModels[i] = this._pushInternalModel(jsonApiDoc.data[i]);\n }\n return internalModels;\n }\n if (jsonApiDoc.data === null) {\n return null;\n }\n (!(utils.typeOf(jsonApiDoc.data) === 'object') && debug.assert(`Expected an object in the 'data' property in a call to 'push' for ${jsonApiDoc.type}, but was ${utils.typeOf(jsonApiDoc.data)}`, utils.typeOf(jsonApiDoc.data) === 'object'));\n return this._pushInternalModel(jsonApiDoc.data);\n });\n\n // this typecast is necessary because `backburner.join` is mistyped to return void\n return internalModelOrModels;\n }\n _pushInternalModel(data) {\n let modelName = data.type;\n (!(data.id !== null && data.id !== undefined && data.id !== '') && debug.assert(`You must include an 'id' for ${modelName} in an object passed to 'push'`, data.id !== null && data.id !== undefined && data.id !== ''));\n (!(this._hasModelFor(modelName)) && debug.assert(`You tried to push data with a type '${modelName}' but no model could be found with that name.`, this._hasModelFor(modelName)));\n {\n // If ENV.DS_WARN_ON_UNKNOWN_KEYS is set to true and the payload\n // contains unknown attributes or relationships, log a warning.\n\n if (ENV.DS_WARN_ON_UNKNOWN_KEYS) {\n let unknownAttributes, unknownRelationships;\n let relationships = this.getSchemaDefinitionService().relationshipsDefinitionFor(modelName);\n let attributes = this.getSchemaDefinitionService().attributesDefinitionFor(modelName);\n // Check unknown attributes\n unknownAttributes = Object.keys(data.attributes || {}).filter(key => {\n return !attributes[key];\n });\n\n // Check unknown relationships\n unknownRelationships = Object.keys(data.relationships || {}).filter(key => {\n return !relationships[key];\n });\n let unknownAttributesMessage = `The payload for '${modelName}' contains these unknown attributes: ${unknownAttributes}. Make sure they've been defined in your model.`;\n (debug.warn(unknownAttributesMessage, unknownAttributes.length === 0, {\n id: 'ds.store.unknown-keys-in-payload'\n }));\n let unknownRelationshipsMessage = `The payload for '${modelName}' contains these unknown relationships: ${unknownRelationships}. Make sure they've been defined in your model.`;\n (debug.warn(unknownRelationshipsMessage, unknownRelationships.length === 0, {\n id: 'ds.store.unknown-keys-in-payload'\n }));\n }\n }\n\n // Actually load the record into the store.\n let internalModel = this._load(data);\n\n // this._setupRelationshipsForModel(internalModel, data);\n\n return internalModel;\n }\n\n /**\n Push some raw data into the store.\n This method can be used both to push in brand new\n records, as well as to update existing records. You\n can push in more than one type of object at once.\n All objects should be in the format expected by the\n serializer.\n ```app/serializers/application.js\n import RESTSerializer from '@ember-data/serializer/rest';\n export default class ApplicationSerializer extends RESTSerializer;\n ```\n ```js\n let pushData = {\n posts: [\n { id: 1, postTitle: \"Great post\", commentIds: [2] }\n ],\n comments: [\n { id: 2, commentBody: \"Insightful comment\" }\n ]\n }\n store.pushPayload(pushData);\n ```\n By default, the data will be deserialized using a default\n serializer (the application serializer if it exists).\n Alternatively, `pushPayload` will accept a model type which\n will determine which serializer will process the payload.\n ```app/serializers/application.js\n import RESTSerializer from '@ember-data/serializer/rest';\n export default class ApplicationSerializer extends RESTSerializer;\n ```\n ```app/serializers/post.js\n import JSONSerializer from '@ember-data/serializer/json';\n export default JSONSerializer;\n ```\n ```js\n store.pushPayload(pushData); // Will use the application serializer\n store.pushPayload('post', pushData); // Will use the post serializer\n ```\n @method pushPayload\n @public\n @param {String} modelName Optionally, a model type used to determine which serializer will be used\n @param {Object} inputPayload\n */\n pushPayload(modelName, inputPayload) {\n {\n assertDestroyingStore$1(this, 'pushPayload');\n }\n let serializer;\n let payload;\n if (!inputPayload) {\n payload = modelName;\n serializer = this.serializerFor('application');\n (!(typeof serializer.pushPayload === 'function') && debug.assert(`You cannot use 'store#pushPayload' without a modelName unless your default serializer defines 'pushPayload'`, typeof serializer.pushPayload === 'function'));\n } else {\n payload = inputPayload;\n (!(typeof modelName === 'string') && debug.assert(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${modelName}`, typeof modelName === 'string'));\n let normalizedModelName = normalizeModelName(modelName);\n serializer = this.serializerFor(normalizedModelName);\n }\n (!(serializer.pushPayload) && debug.assert(`You must define a pushPayload method in your serializer in order to call store.pushPayload`, serializer.pushPayload));\n serializer.pushPayload(this, payload);\n }\n reloadManyArray(manyArray, internalModel, key, options) {\n return internalModel.reloadHasMany(key, options);\n }\n reloadBelongsTo(belongsToProxy, internalModel, key, options) {\n return internalModel.reloadBelongsTo(key, options);\n }\n _internalModelForResource(resource) {\n return internalModelFactoryFor(this).getByResource(resource);\n }\n\n /**\n * TODO Only needed temporarily for test support\n *\n * @method _internalModelForId\n * @internal\n */\n _internalModelForId(type, id, lid) {\n const resource = constructResource(type, id, lid);\n return internalModelFactoryFor(this).lookup(resource);\n }\n serializeRecord(record, options) {\n let identifier = recordIdentifierFor(record);\n let internalModel = internalModelFactoryFor(this).peek(identifier);\n // TODO we used to check if the record was destroyed here\n return internalModel.createSnapshot(options).serialize(options);\n }\n saveRecord(record, options) {\n let identifier = recordIdentifierFor(record);\n let internalModel = internalModelFactoryFor(this).peek(identifier);\n // TODO we used to check if the record was destroyed here\n // Casting can be removed once REQUEST_SERVICE ff is turned on\n // because a `Record` is provided there will always be a matching internalModel\n return internalModel.save(options).then(() => record);\n }\n relationshipReferenceFor(identifier, key) {\n let stableIdentifier = this.identifierCache.getOrCreateRecordIdentifier(identifier);\n let internalModel = internalModelFactoryFor(this).peek(stableIdentifier);\n // TODO we used to check if the record was destroyed here\n return internalModel.referenceFor(null, key);\n }\n\n /**\n * Manages setting setting up the recordData returned by createRecordDataFor\n *\n * @method _createRecordData\n * @internal\n */\n _createRecordData(identifier) {\n const recordData = this.createRecordDataFor(identifier.type, identifier.id, identifier.lid, this._storeWrapper);\n setRecordDataFor(identifier, recordData);\n // TODO this is invalid for v2 recordData but required\n // for v1 recordData. Remember to remove this once the\n // RecordData manager handles converting recordData to identifier\n setRecordIdentifier(recordData, identifier);\n return recordData;\n }\n\n /**\n * Instantiation hook allowing applications or addons to configure the store\n * to utilize a custom RecordData implementation.\n *\n * @method createRecordDataFor\n * @public\n * @param modelName\n * @param id\n * @param clientId\n * @param storeWrapper\n */\n createRecordDataFor(modelName, id, clientId, storeWrapper) {\n {\n // we can't greedily use require as this causes\n // a cycle we can't easily fix (or clearly pin point) at present.\n //\n // it can be reproduced in partner tests by running\n // node ./scripts/packages-for-commit.js && yarn test-external:ember-observer\n if (_RecordData === undefined) {\n _RecordData = require__default[\"default\"]('@ember-data/record-data/-private').RecordData;\n }\n let identifier = this.identifierCache.getOrCreateRecordIdentifier({\n type: modelName,\n id,\n lid: clientId\n });\n return new _RecordData(identifier, storeWrapper);\n }\n }\n\n /**\n * @internal\n */\n __recordDataFor(resource) {\n const identifier = this.identifierCache.getOrCreateRecordIdentifier(resource);\n return this.recordDataFor(identifier, false);\n }\n\n /**\n * @internal\n */\n recordDataFor(identifier, isCreate) {\n let internalModel;\n if (isCreate === true) {\n internalModel = internalModelFactoryFor(this).build({\n type: identifier.type,\n id: null\n });\n internalModel.send('loadedData');\n internalModel.didCreateRecord();\n } else {\n internalModel = internalModelFactoryFor(this).lookup(identifier);\n }\n return internalModel._recordData;\n }\n\n /**\n `normalize` converts a json payload into the normalized form that\n [push](../methods/push?anchor=push) expects.\n Example\n ```js\n socket.on('message', function(message) {\n let modelName = message.model;\n let data = message.data;\n store.push(store.normalize(modelName, data));\n });\n ```\n @method normalize\n @public\n @param {String} modelName The name of the model type for this payload\n @param {Object} payload\n @return {Object} The normalized payload\n */\n normalize(modelName, payload) {\n {\n assertDestroyingStore$1(this, 'normalize');\n }\n (!(utils.isPresent(modelName)) && debug.assert(`You need to pass a model name to the store's normalize method`, utils.isPresent(modelName)));\n (!(typeof modelName === 'string') && debug.assert(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${debug.inspect(modelName)}`, typeof modelName === 'string'));\n let normalizedModelName = normalizeModelName(modelName);\n let serializer = this.serializerFor(normalizedModelName);\n let model = this.modelFor(normalizedModelName);\n (!(serializer.normalize) && debug.assert(`You must define a normalize method in your serializer in order to call store.normalize`, serializer.normalize));\n return serializer.normalize(model, payload);\n }\n newClientId() {\n (debug.assert(`Private API Removed`, false));\n }\n\n // ...............\n // . DESTRUCTION .\n // ...............\n\n /**\n * TODO remove test usage\n *\n * @internal\n */\n _internalModelsFor(modelName) {\n return internalModelFactoryFor(this).modelMapFor(modelName);\n }\n\n // ......................\n // . PER-TYPE ADAPTERS\n // ......................\n\n /**\n Returns an instance of the adapter for a given type. For\n example, `adapterFor('person')` will return an instance of\n `App.PersonAdapter`.\n If no `App.PersonAdapter` is found, this method will look\n for an `App.ApplicationAdapter` (the default adapter for\n your entire application).\n If no `App.ApplicationAdapter` is found, it will return\n the value of the `defaultAdapter`.\n @method adapterFor\n @public\n @param {String} modelName\n @return Adapter\n */\n adapterFor(modelName) {\n {\n assertDestroyingStore$1(this, 'adapterFor');\n }\n (!(utils.isPresent(modelName)) && debug.assert(`You need to pass a model name to the store's adapterFor method`, utils.isPresent(modelName)));\n (!(typeof modelName === 'string') && debug.assert(`Passing classes to store.adapterFor has been removed. Please pass a dasherized string instead of ${modelName}`, typeof modelName === 'string'));\n let normalizedModelName = normalizeModelName(modelName);\n let {\n _adapterCache\n } = this;\n let adapter = _adapterCache[normalizedModelName];\n if (adapter) {\n return adapter;\n }\n let owner = application.getOwner(this);\n\n // name specific adapter\n adapter = owner.lookup(`adapter:${normalizedModelName}`);\n if (adapter !== undefined) {\n object.set(adapter, 'store', this);\n _adapterCache[normalizedModelName] = adapter;\n return adapter;\n }\n\n // no adapter found for the specific name, fallback and check for application adapter\n adapter = _adapterCache.application || owner.lookup('adapter:application');\n if (adapter !== undefined) {\n object.set(adapter, 'store', this);\n _adapterCache[normalizedModelName] = adapter;\n _adapterCache.application = adapter;\n return adapter;\n }\n\n // final fallback, no model specific adapter, no application adapter, no\n // `adapter` property on store: use json-api adapter\n // TODO we should likely deprecate this?\n adapter = _adapterCache['-json-api'] || owner.lookup('adapter:-json-api');\n (!(adapter !== undefined) && debug.assert(`No adapter was found for '${modelName}' and no 'application' adapter was found as a fallback.`, adapter !== undefined));\n object.set(adapter, 'store', this);\n _adapterCache[normalizedModelName] = adapter;\n _adapterCache['-json-api'] = adapter;\n return adapter;\n }\n\n // ..............................\n // . RECORD CHANGE NOTIFICATION .\n // ..............................\n\n /**\n Returns an instance of the serializer for a given type. For\n example, `serializerFor('person')` will return an instance of\n `App.PersonSerializer`.\n If no `App.PersonSerializer` is found, this method will look\n for an `App.ApplicationSerializer` (the default serializer for\n your entire application).\n If a serializer cannot be found on the adapter, it will fall back\n to an instance of `JSONSerializer`.\n @method serializerFor\n @public\n @param {String} modelName the record to serialize\n @return {Serializer}\n */\n serializerFor(modelName) {\n {\n assertDestroyingStore$1(this, 'serializerFor');\n }\n (!(utils.isPresent(modelName)) && debug.assert(`You need to pass a model name to the store's serializerFor method`, utils.isPresent(modelName)));\n (!(typeof modelName === 'string') && debug.assert(`Passing classes to store.serializerFor has been removed. Please pass a dasherized string instead of ${modelName}`, typeof modelName === 'string'));\n let normalizedModelName = normalizeModelName(modelName);\n let {\n _serializerCache\n } = this;\n let serializer = _serializerCache[normalizedModelName];\n if (serializer) {\n return serializer;\n }\n let owner = application.getOwner(this);\n\n // by name\n serializer = owner.lookup(`serializer:${normalizedModelName}`);\n if (serializer !== undefined) {\n object.set(serializer, 'store', this);\n _serializerCache[normalizedModelName] = serializer;\n return serializer;\n }\n\n // no serializer found for the specific model, fallback and check for application serializer\n serializer = _serializerCache.application || owner.lookup('serializer:application');\n if (serializer !== undefined) {\n object.set(serializer, 'store', this);\n _serializerCache[normalizedModelName] = serializer;\n _serializerCache.application = serializer;\n return serializer;\n }\n (!(serializer !== undefined) && debug.assert(`No serializer was found for '${modelName}' and no 'application' serializer was found as a fallback`, serializer !== undefined));\n }\n destroy() {\n // enqueue destruction of any adapters/serializers we have created\n for (let adapterName in this._adapterCache) {\n let adapter = this._adapterCache[adapterName];\n if (typeof adapter.destroy === 'function') {\n adapter.destroy();\n }\n }\n for (let serializerName in this._serializerCache) {\n let serializer = this._serializerCache[serializerName];\n if (typeof serializer.destroy === 'function') {\n serializer.destroy();\n }\n }\n {\n const peekGraph = require__default[\"default\"]('@ember-data/record-data/-private').peekGraph;\n let graph = peekGraph(this);\n if (graph) {\n graph.destroy();\n }\n }\n return super.destroy();\n }\n willDestroy() {\n super.willDestroy();\n this.recordArrayManager.destroy();\n this.identifierCache.destroy();\n\n // destroy the graph before unloadAll\n // since then we avoid churning relationships\n // during unload\n {\n const peekGraph = require__default[\"default\"]('@ember-data/record-data/-private').peekGraph;\n let graph = peekGraph(this);\n if (graph) {\n graph.willDestroy();\n }\n }\n this.unloadAll();\n {\n test.unregisterWaiter(this.__asyncWaiter);\n let shouldTrack = this.shouldTrackAsyncRequests;\n let tracked = this._trackedAsyncRequests;\n let isSettled = tracked.length === 0;\n if (!isSettled) {\n if (shouldTrack) {\n throw new Error('Async Request leaks detected. Add a breakpoint here and set `store.generateStackTracesForTrackedRequests = true;`to inspect traces for leak origins:\\n\\t - ' + tracked.map(o => o.label).join('\\n\\t - '));\n } else {\n (debug.warn('Async Request leaks detected. Add a breakpoint here and set `store.generateStackTracesForTrackedRequests = true;`to inspect traces for leak origins:\\n\\t - ' + tracked.map(o => o.label).join('\\n\\t - '), false, {\n id: 'ds.async.leak.detected'\n }));\n }\n }\n }\n }\n _updateInternalModel(internalModel) {\n if (this._updatedInternalModels.push(internalModel) !== 1) {\n return;\n }\n runloop._backburner.schedule('actions', this, this._flushUpdatedInternalModels);\n }\n _flushUpdatedInternalModels() {\n let updated = this._updatedInternalModels;\n for (let i = 0, l = updated.length; i < l; i++) {\n updated[i]._triggerDeferredTriggers();\n }\n updated.length = 0;\n }\n }\n let assertDestroyingStore$1;\n let assertDestroyedStoreOnly$1;\n {\n assertDestroyingStore$1 = function assertDestroyedStore(store, method) {\n (!(!(store.isDestroying || store.isDestroyed)) && debug.assert(`Attempted to call store.${method}(), but the store instance has already been destroyed.`, !(store.isDestroying || store.isDestroyed)));\n };\n assertDestroyedStoreOnly$1 = function assertDestroyedStoreOnly(store, method) {\n (!(!store.isDestroyed) && debug.assert(`Attempted to call store.${method}(), but the store instance has already been destroyed.`, !store.isDestroyed));\n };\n }\n\n /**\n * Flag indicating whether all inverse records are available\n *\n * true if the inverse exists and is loaded (not empty)\n * true if there is no inverse\n * false if the inverse exists and is not loaded (empty)\n *\n * @internal\n * @return {boolean}\n */\n function areAllInverseRecordsLoaded(store, resource) {\n const cache = store.identifierCache;\n if (Array.isArray(resource.data)) {\n // treat as collection\n // check for unloaded records\n let hasEmptyRecords = resource.data.reduce((hasEmptyModel, resourceIdentifier) => {\n return hasEmptyModel || internalModelForRelatedResource(store, cache, resourceIdentifier).currentState.isEmpty;\n }, false);\n return !hasEmptyRecords;\n } else {\n // treat as single resource\n if (!resource.data) {\n return true;\n } else {\n const internalModel = internalModelForRelatedResource(store, cache, resource.data);\n return !internalModel.currentState.isEmpty;\n }\n }\n }\n function internalModelForRelatedResource(store, cache, resource) {\n const identifier = cache.getOrCreateRecordIdentifier(resource);\n return store._internalModelForResource(identifier);\n }\n function isMaybeIdentifier(maybeIdentifier) {\n return Boolean(maybeIdentifier !== null && typeof maybeIdentifier === 'object' && ('id' in maybeIdentifier && 'type' in maybeIdentifier && maybeIdentifier.id && maybeIdentifier.type || maybeIdentifier.lid));\n }\n function assertIdentifierHasId(identifier) {\n (!(identifier.id !== null) && debug.assert(`Attempted to schedule a fetch for a record without an id.`, identifier.id !== null));\n }\n\n let _modelForMixin;\n {\n let _found;\n _modelForMixin = function () {\n if (!_found) {\n _found = require__default[\"default\"]('@ember-data/model/-private')._modelForMixin;\n }\n return _found(...arguments);\n };\n }\n class DSModelSchemaDefinitionService {\n constructor(store) {\n this._modelFactoryCache = Object.create(null);\n this._relationshipsDefCache = Object.create(null);\n this._attributesDefCache = Object.create(null);\n this.store = store;\n }\n\n // Following the existing RD implementation\n attributesDefinitionFor(identifier) {\n let modelName, attributes;\n if (typeof identifier === 'string') {\n modelName = identifier;\n } else {\n modelName = identifier.type;\n }\n attributes = this._attributesDefCache[modelName];\n if (attributes === undefined) {\n let modelClass = this.store.modelFor(modelName);\n let attributeMap = object.get(modelClass, 'attributes');\n attributes = Object.create(null);\n attributeMap.forEach((meta, name) => attributes[name] = meta);\n this._attributesDefCache[modelName] = attributes;\n }\n return attributes;\n }\n\n // Following the existing RD implementation\n relationshipsDefinitionFor(identifier) {\n let modelName, relationships;\n if (typeof identifier === 'string') {\n modelName = identifier;\n } else {\n modelName = identifier.type;\n }\n relationships = this._relationshipsDefCache[modelName];\n if (relationships === undefined) {\n let modelClass = this.store.modelFor(modelName);\n relationships = object.get(modelClass, 'relationshipsObject') || null;\n this._relationshipsDefCache[modelName] = relationships;\n }\n return relationships;\n }\n doesTypeExist(modelName) {\n let normalizedModelName = normalizeModelName(modelName);\n let factory = getModelFactory(this.store, this._modelFactoryCache, normalizedModelName);\n return factory !== null;\n }\n }\n function getModelFactory(store, cache, normalizedModelName) {\n let factory = cache[normalizedModelName];\n if (!factory) {\n factory = _lookupModelFactory(store, normalizedModelName);\n if (!factory && true /* HAS_MODEL_PACKAGE */) {\n //Support looking up mixins as base types for polymorphic relationships\n factory = _modelForMixin(store, normalizedModelName);\n }\n if (!factory) {\n // we don't cache misses in case someone wants to register a missing model\n return null;\n }\n let klass = factory.class;\n if (klass.isModel) {\n let hasOwnModelNameSet = klass.modelName && Object.prototype.hasOwnProperty.call(klass, 'modelName');\n if (!hasOwnModelNameSet) {\n Object.defineProperty(klass, 'modelName', {\n value: normalizedModelName\n });\n }\n }\n cache[normalizedModelName] = factory;\n }\n return factory;\n }\n function _lookupModelFactory(store, normalizedModelName) {\n let owner = application.getOwner(store);\n return owner.factoryFor(`model:${normalizedModelName}`);\n }\n\n class Store extends CoreStore {\n constructor(...args) {\n super(...args);\n this._modelFactoryCache = Object.create(null);\n this._relationshipsDefCache = Object.create(null);\n this._attributesDefCache = Object.create(null);\n }\n instantiateRecord(identifier, createRecordArgs, recordDataFor, notificationManager) {\n let modelName = identifier.type;\n let internalModel = this._internalModelForResource(identifier);\n let createOptions = {\n store: this,\n _internalModel: internalModel,\n // TODO deprecate allowing unknown args setting\n _createProps: createRecordArgs,\n container: null\n };\n\n // ensure that `getOwner(this)` works inside a model instance\n application.setOwner(createOptions, application.getOwner(this));\n delete createOptions.container;\n let record = this._modelFactoryFor(modelName).create(createOptions);\n return record;\n }\n teardownRecord(record) {\n record.destroy();\n }\n modelFor(modelName) {\n {\n assertDestroyedStoreOnly(this, 'modelFor');\n }\n (!(utils.isPresent(modelName)) && debug.assert(`You need to pass a model name to the store's modelFor method`, utils.isPresent(modelName)));\n (!(typeof modelName === 'string') && debug.assert(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${modelName}`, typeof modelName === 'string'));\n let maybeFactory = this._modelFactoryFor(modelName);\n\n // for factorFor factory/class split\n let klass = maybeFactory && maybeFactory.class ? maybeFactory.class : maybeFactory;\n if (!klass || !klass.isModel) {\n if (!this.getSchemaDefinitionService().doesTypeExist(modelName)) {\n throw new EmberError__default[\"default\"](`No model was found for '${modelName}' and no schema handles the type`);\n }\n return getShimClass(this, modelName);\n } else {\n return klass;\n }\n }\n _modelFactoryFor(modelName) {\n {\n assertDestroyedStoreOnly(this, '_modelFactoryFor');\n }\n (!(utils.isPresent(modelName)) && debug.assert(`You need to pass a model name to the store's _modelFactoryFor method`, utils.isPresent(modelName)));\n (!(typeof modelName === 'string') && debug.assert(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${modelName}`, typeof modelName === 'string'));\n let normalizedModelName = normalizeModelName(modelName);\n let factory = getModelFactory(this, this._modelFactoryCache, normalizedModelName);\n return factory;\n }\n _hasModelFor(modelName) {\n {\n assertDestroyingStore(this, '_hasModelFor');\n }\n (!(utils.isPresent(modelName)) && debug.assert(`You need to pass a model name to the store's hasModelFor method`, utils.isPresent(modelName)));\n (!(typeof modelName === 'string') && debug.assert(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${modelName}`, typeof modelName === 'string'));\n return this.getSchemaDefinitionService().doesTypeExist(modelName);\n }\n _relationshipMetaFor(modelName, id, key) {\n return this._relationshipsDefinitionFor({\n type: modelName\n })[key];\n }\n _attributesDefinitionFor(identifier) {\n return this.getSchemaDefinitionService().attributesDefinitionFor(identifier);\n }\n _relationshipsDefinitionFor(identifier) {\n return this.getSchemaDefinitionService().relationshipsDefinitionFor(identifier);\n }\n getSchemaDefinitionService() {\n if (!this._schemaDefinitionService) {\n this._schemaDefinitionService = new DSModelSchemaDefinitionService(this);\n }\n return this._schemaDefinitionService;\n }\n }\n let assertDestroyingStore;\n let assertDestroyedStoreOnly;\n {\n assertDestroyingStore = function assertDestroyedStore(store, method) {\n (!(!(store.isDestroying || store.isDestroyed)) && debug.assert(`Attempted to call store.${method}(), but the store instance has already been destroyed.`, !(store.isDestroying || store.isDestroyed)));\n };\n assertDestroyedStoreOnly = function assertDestroyedStoreOnly(store, method) {\n (!(!store.isDestroyed) && debug.assert(`Attempted to call store.${method}(), but the store instance has already been destroyed.`, !store.isDestroyed));\n };\n }\n\n exports.AdapterPopulatedRecordArray = AdapterPopulatedRecordArray;\n exports.InternalModel = InternalModel;\n exports.PromiseArray = PromiseArray;\n exports.PromiseObject = PromiseObject;\n exports.RecordArray = RecordArray;\n exports.RecordArrayManager = RecordArrayManager;\n exports.RecordDataStoreWrapper = RecordDataStoreWrapper;\n exports.RootState = RootState$1;\n exports.Snapshot = Snapshot;\n exports.SnapshotRecordArray = SnapshotRecordArray;\n exports.Store = Store;\n exports.WeakCache = WeakCache$1;\n exports.coerceId = coerceId;\n exports.deprecatedPromiseObject = deprecatedPromiseObject;\n exports.errorsArrayToHash = errorsArrayToHash;\n exports.errorsHashToArray = errorsHashToArray;\n exports.normalizeModelName = normalizeModelName;\n exports.recordDataFor = recordDataFor;\n exports.recordIdentifierFor = recordIdentifierFor;\n exports.removeRecordDataFor = removeRecordDataFor;\n exports.setIdentifierForgetMethod = setIdentifierForgetMethod;\n exports.setIdentifierGenerationMethod = setIdentifierGenerationMethod;\n exports.setIdentifierResetMethod = setIdentifierResetMethod;\n exports.setIdentifierUpdateMethod = setIdentifierUpdateMethod;\n\n Object.defineProperty(exports, '__esModule', { value: true });\n\n}));\n","define(\"@ember-data/store/index\", [\"exports\", \"@ember-data/store/-private\"], function (_exports, _private) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n Object.defineProperty(_exports, \"default\", {\n enumerable: true,\n get: function () {\n return _private.Store;\n }\n });\n Object.defineProperty(_exports, \"normalizeModelName\", {\n enumerable: true,\n get: function () {\n return _private.normalizeModelName;\n }\n });\n Object.defineProperty(_exports, \"recordIdentifierFor\", {\n enumerable: true,\n get: function () {\n return _private.recordIdentifierFor;\n }\n });\n Object.defineProperty(_exports, \"setIdentifierForgetMethod\", {\n enumerable: true,\n get: function () {\n return _private.setIdentifierForgetMethod;\n }\n });\n Object.defineProperty(_exports, \"setIdentifierGenerationMethod\", {\n enumerable: true,\n get: function () {\n return _private.setIdentifierGenerationMethod;\n }\n });\n Object.defineProperty(_exports, \"setIdentifierResetMethod\", {\n enumerable: true,\n get: function () {\n return _private.setIdentifierResetMethod;\n }\n });\n Object.defineProperty(_exports, \"setIdentifierUpdateMethod\", {\n enumerable: true,\n get: function () {\n return _private.setIdentifierUpdateMethod;\n }\n });\n 0; //eaimeta@70e063a35619d71f0,\"@ember-data/store/-private\"eaimeta@70e063a35619d71f\n /**\n @module @ember-data/store\n */\n});","define(\"@ember-decorators/component/index\", [\"exports\", \"@ember/debug\", \"@ember-decorators/utils/collapse-proto\", \"@ember-decorators/utils/decorator\"], function (_exports, _debug, _collapseProto, _decorator) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.tagName = _exports.layout = _exports.classNames = _exports.classNameBindings = _exports.className = _exports.attributeBindings = _exports.attribute = void 0;\n /**\n Decorator which indicates that the field or computed should be bound\n to an attribute value on the component. This replaces `attributeBindings`\n by directly allowing you to specify which properties should be bound.\n ```js\n export default class AttributeDemoComponent extends Component {\n @attribute role = 'button';\n // With provided attribute name\n @attribute('data-foo') foo = 'lol';\n @attribute\n @computed\n get id() {\n // return generated id\n }\n }\n ```\n @function\n @param {string} name? - The name of the attribute to bind the value to if it is truthy\n */\n const attribute = _exports.attribute = (0, _decorator.decoratorWithParams)((target, key, desc, params = []) => {\n (true && !(params.length <= 1) && (0, _debug.assert)(`The @attribute decorator may take up to one parameter, the bound attribute name. Received: ${params.length}`, params.length <= 1));\n (true && !(params.every(s => typeof s === 'string')) && (0, _debug.assert)(`The @attribute decorator may only receive strings as parameters. Received: ${params}`, params.every(s => typeof s === 'string')));\n (0, _collapseProto.default)(target);\n if (!target.hasOwnProperty('attributeBindings')) {\n let parentValue = target.attributeBindings;\n target.attributeBindings = Array.isArray(parentValue) ? parentValue.slice() : [];\n }\n let binding = params[0] ? `${key}:${params[0]}` : key;\n target.attributeBindings.push(binding);\n if (desc) {\n // Decorated fields are currently not configurable in Babel for some reason, so ensure\n // that the field becomes configurable (else it messes with things)\n desc.configurable = true;\n }\n return desc;\n });\n\n /**\n Decorator which indicates that the field or computed should be bound to\n the component class names. This replaces `classNameBindings` by directly\n allowing you to specify which properties should be bound.\n ```js\n export default class ClassNameDemoComponent extends Component {\n @className boundField = 'default-class';\n // With provided true/false class names\n @className('active', 'inactive') isActive = true;\n @className\n @computed\n get boundComputed() {\n // return generated class\n }\n }\n ```\n @function\n @param {string} truthyName? - The class to be applied if the value the field\n is truthy, defaults to the name of the field.\n @param {string} falsyName? - The class to be applied if the value of the field\n is falsy.\n */\n const className = _exports.className = (0, _decorator.decoratorWithParams)((target, key, desc, params = []) => {\n (true && !(params.length <= 2) && (0, _debug.assert)(`The @className decorator may take up to two parameters, the truthy class and falsy class for the class binding. Received: ${params.length}`, params.length <= 2));\n (true && !(params.every(s => typeof s === 'string')) && (0, _debug.assert)(`The @className decorator may only receive strings as parameters. Received: ${params}`, params.every(s => typeof s === 'string')));\n (0, _collapseProto.default)(target);\n if (!target.hasOwnProperty('classNameBindings')) {\n let parentValue = target.classNameBindings;\n target.classNameBindings = Array.isArray(parentValue) ? parentValue.slice() : [];\n }\n let binding = params.length > 0 ? `${key}:${params.join(':')}` : key;\n target.classNameBindings.push(binding);\n if (desc) {\n // Decorated fields are currently not configurable in Babel for some reason, so ensure\n // that the field becomes configurable (else it messes with things)\n desc.configurable = true;\n }\n return desc;\n });\n function concattedPropDecorator(propName) {\n return (0, _decorator.decoratorWithRequiredParams)((target, propValues) => {\n (true && !(propValues.reduce((allStrings, name) => allStrings && typeof name === 'string', true)) && (0, _debug.assert)(`The @${propName} decorator must be provided strings, received: ${propValues}`, propValues.reduce((allStrings, name) => allStrings && typeof name === 'string', true)));\n (0, _collapseProto.default)(target.prototype);\n if (propName in target.prototype) {\n let parentValues = target.prototype[propName];\n propValues.unshift(...parentValues);\n }\n target.prototype[propName] = propValues;\n return target;\n }, propName);\n }\n\n /**\n Class decorator which specifies the class names to be applied to a component.\n This replaces the `classNames` property on components in the traditional Ember\n object model.\n ```js\n @classNames('a-static-class', 'another-static-class')\n export default class ClassNamesDemoComponent extends Component {}\n ```\n @function\n @param {...string} classNames - The list of classes to be applied to the component\n */\n const classNames = _exports.classNames = concattedPropDecorator('classNames');\n\n /**\n Class decorator which specifies the class name bindings to be applied to a\n component. This replaces the `classNameBindings` property on components in the\n traditional Ember object model.\n ```js\n @classNameBindings('aDynamicProperty:truthy-class-name:falsy-class-name')\n export default class ClassNamesDemoComponent extends Component {}\n ```\n @function\n @param {...string} classNameBindings - The list of class name bindings to be applied to the component\n */\n const classNameBindings = _exports.classNameBindings = concattedPropDecorator('classNameBindings');\n\n /**\n Class decorator which specifies the attribute bindings to be applied to a\n component. This replaces the `attributeBindings` property on components in the\n traditional Ember object model.\n ```js\n @attributeBindings('role', 'aProperty:a-different-attribute')\n export default class ClassNamesDemoComponent extends Component {}\n ```\n @function\n @param {...string} attributeBindings - The list of attribute bindings to be applied to the component\n */\n const attributeBindings = _exports.attributeBindings = concattedPropDecorator('attributeBindings');\n\n /**\n Class decorator which specifies the tag name of the component. This replaces\n the `tagName` property on components in the traditional Ember object model.\n ```js\n @tagName('button')\n export default class TagNameDemoComponent extends Component {}\n ```\n @function\n @param {string} tagName - The HTML tag to be used for the component\n */\n const tagName = _exports.tagName = (0, _decorator.decoratorWithRequiredParams)((target, params) => {\n let [tagName] = params;\n (true && !(params.length === 1) && (0, _debug.assert)(`The @tagName decorator must be provided exactly one argument, received: ${tagName}`, params.length === 1));\n (true && !(typeof tagName === 'string') && (0, _debug.assert)(`The @tagName decorator must be provided a string, received: ${tagName}`, typeof tagName === 'string'));\n target.prototype.tagName = tagName;\n return target;\n }, 'tagName');\n\n /**\n Class decorator which specifies the layout for the component. This replaces\n the `layout` property on components in the traditional Ember object model.\n ```js\n import template from '../templates/components/x-foo';\n @layout(template)\n export default class TagNameDemoComponent extends Component {}\n ```\n ```js\n import hbs from 'htmlbars-inline-precompile';\n @layout(hbs`
Hello {{ name }}
`)\n export default class TagNameDemoComponent extends Component {\n constructor() {\n super(...arguments);\n this.set('name', 'Tomster');\n }\n }\n ```\n @function\n @param {TemplateFactory} template - The compiled template to be used for the component\n */\n const layout = (...params) => target => {\n let [template] = params;\n (true && !(params.length === 1) && (0, _debug.assert)(`The @layout decorator must be provided exactly one argument, received: ${params.length}`, params.length === 1));\n (true && !(typeof template !== 'string') && (0, _debug.assert)(`The @layout decorator must be provided a template, received: ${template}. If you want to compile strings to templates, be sure to use 'htmlbars-inline-precompile'`, typeof template !== 'string'));\n (true && !(typeof template === 'function' || typeof template === 'object' && typeof template.indexOf === 'undefined') && (0, _debug.assert)(`The @layout decorator must be provided a template, received: ${template}`, typeof template === 'function' || typeof template === 'object' && typeof template.indexOf === 'undefined'));\n target.prototype.layout = template;\n return target;\n };\n _exports.layout = layout;\n});","define(\"@ember-decorators/object/index\", [\"exports\", \"@ember/debug\", \"@ember/object\", \"@ember/object/computed\", \"@ember/object/events\", \"@ember/object/observers\", \"@ember-decorators/utils/decorator\"], function (_exports, _debug, _object, _computed, _events, _observers, _decorator) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.unobserves = _exports.on = _exports.off = _exports.observes = void 0;\n /**\n Triggers the target function when the dependent properties have changed. Note,\n `@observes` _must_ be used on EmberObject based classes only, otherwise there\n may be subtle issues and breakage.\n \n ```javascript\n import { observes } from '@ember-decorators/object';\n \n class Foo {\n @observes('foo')\n bar() {\n //...\n }\n }\n ```\n \n @function\n @param {...String} propertyNames - Names of the properties that trigger the function\n */\n const observes = _exports.observes = (0, _decorator.decoratorWithRequiredParams)((target, key, desc, params) => {\n (true && !(desc && typeof desc.value === 'function') && (0, _debug.assert)('The @observes decorator must be applied to functions', desc && typeof desc.value === 'function'));\n (true && !(target instanceof _object.default) && (0, _debug.assert)(`You attempted to use @observes on ${target.constructor.name}#${key}, which does not extend from EmberObject. Unfortunately this does not work with stage 1 decorator transforms, and will break in subtle ways. You must rewrite your class to extend from EmberObject.`, target instanceof _object.default));\n for (let path of params) {\n (0, _computed.expandProperties)(path, expandedPath => {\n (0, _observers.addObserver)(target, expandedPath, null, key);\n });\n }\n return desc;\n }, 'observes');\n\n /**\n Removes observers from the target function.\n \n ```javascript\n import { observes, unobserves } from '@ember-decorators/object';\n \n class Foo {\n @observes('foo')\n bar() {\n //...\n }\n }\n \n class Bar extends Foo {\n @unobserves('foo') bar;\n }\n ```\n \n @function\n @param {...String} propertyNames - Names of the properties that no longer trigger the function\n */\n const unobserves = _exports.unobserves = (0, _decorator.decoratorWithRequiredParams)((target, key, desc, params) => {\n for (let path of params) {\n (0, _computed.expandProperties)(path, expandedPath => {\n (0, _observers.removeObserver)(target, expandedPath, null, key);\n });\n }\n return desc;\n }, 'unobserves');\n\n /**\n Adds an event listener to the target function.\n \n ```javascript\n import { on } from '@ember-decorators/object';\n \n class Foo {\n @on('fooEvent', 'barEvent')\n bar() {\n //...\n }\n }\n ```\n \n @function\n @param {...String} eventNames - Names of the events that trigger the function\n */\n const on = _exports.on = (0, _decorator.decoratorWithRequiredParams)((target, key, desc, params) => {\n (true && !(desc && typeof desc.value === 'function') && (0, _debug.assert)('The @on decorator must be applied to functions', desc && typeof desc.value === 'function'));\n for (let eventName of params) {\n (0, _events.addListener)(target, eventName, null, key);\n }\n return desc;\n }, 'on');\n\n /**\n Removes an event listener from the target function.\n \n ```javascript\n import { on, off } from '@ember-decorators/object';\n \n class Foo {\n @on('fooEvent', 'barEvent')\n bar() {\n //...\n }\n }\n \n class Bar extends Foo {\n @off('fooEvent', 'barEvent') bar;\n }\n ```\n \n @function\n @param {...String} eventNames - Names of the events that no longer trigger the function\n */\n const off = _exports.off = (0, _decorator.decoratorWithRequiredParams)((target, key, desc, params) => {\n for (let eventName of params) {\n (0, _events.removeListener)(target, eventName, null, key);\n }\n return desc;\n }, 'off');\n});","define(\"@ember-decorators/utils/-private/class-field-descriptor\", [\"exports\"], function (_exports) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.isDescriptor = isDescriptor;\n _exports.isFieldDescriptor = isFieldDescriptor;\n function isClassDescriptor(possibleDesc) {\n let [target] = possibleDesc;\n return possibleDesc.length === 1 && typeof target === 'function' && 'prototype' in target && !target.__isComputedDecorator;\n }\n function isFieldDescriptor(possibleDesc) {\n let [target, key, desc] = possibleDesc;\n return possibleDesc.length === 3 && typeof target === 'object' && target !== null && typeof key === 'string' && (typeof desc === 'object' && desc !== null && 'enumerable' in desc && 'configurable' in desc || desc === undefined) // TS compatibility\n;\n }\n function isDescriptor(possibleDesc) {\n return isFieldDescriptor(possibleDesc) || isClassDescriptor(possibleDesc);\n }\n});","define(\"@ember-decorators/utils/collapse-proto\", [\"exports\"], function (_exports) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.default = collapseProto;\n function collapseProto(target) {\n // We must collapse the superclass prototype to make sure that the `actions`\n // object will exist. Since collapsing doesn't generally happen until a class is\n // instantiated, we have to do it manually.\n if (typeof target.constructor.proto === 'function') {\n target.constructor.proto();\n }\n }\n});","define(\"@ember-decorators/utils/decorator\", [\"exports\", \"@ember/debug\", \"@ember-decorators/utils/-private/class-field-descriptor\"], function (_exports, _debug, _classFieldDescriptor) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.decoratorWithParams = decoratorWithParams;\n _exports.decoratorWithRequiredParams = decoratorWithRequiredParams;\n /**\n * A macro that takes a decorator function and allows it to optionally\n * receive parameters\n *\n * ```js\n * let foo = decoratorWithParams((target, desc, key, params) => {\n * console.log(params);\n * });\n *\n * class {\n * @foo bar; // undefined\n * @foo('bar') baz; // ['bar']\n * }\n * ```\n *\n * @param {Function} fn - decorator function\n */\n function decoratorWithParams(fn) {\n return function (...params) {\n // determine if user called as @computed('blah', 'blah') or @computed\n if ((0, _classFieldDescriptor.isDescriptor)(params)) {\n return fn(...params);\n } else {\n return (...desc) => fn(...desc, params);\n }\n };\n }\n\n /**\n * A macro that takes a decorator function and requires it to receive\n * parameters:\n *\n * ```js\n * let foo = decoratorWithRequiredParams((target, desc, key, params) => {\n * console.log(params);\n * });\n *\n * class {\n * @foo('bar') baz; // ['bar']\n * @foo bar; // Error\n * }\n * ```\n *\n * @param {Function} fn - decorator function\n */\n function decoratorWithRequiredParams(fn, name) {\n return function (...params) {\n (true && !(!(0, _classFieldDescriptor.isDescriptor)(params) && params.length > 0) && (0, _debug.assert)(`The @${name || fn.name} decorator requires parameters`, !(0, _classFieldDescriptor.isDescriptor)(params) && params.length > 0));\n return (...desc) => fn(...desc, params);\n };\n }\n});","define(\"@ember/render-modifiers/modifiers/did-insert\", [\"exports\", \"@ember/modifier\"], function (_exports, _modifier) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.default = void 0;\n /**\n The `{{did-insert}}` element modifier is activated when an element is\n inserted into the DOM.\n \n In this example, the `fadeIn` function receives the `div` DOM element as its\n first argument and is executed after the element is inserted into the DOM.\n \n ```handlebars\n
\n {{yield}}\n
\n ```\n \n ```js\n export default Component.extend({\n fadeIn(element) {\n element.classList.add('fade-in');\n }\n });\n ```\n \n By default, the executed function will be unbound. If you would like to access\n the component context in your function, use the `action` decorator as follows:\n \n ```handlebars\n
first
\n
second
\n \n
{{this.count}} elements were rendered
\n ```\n \n ```js\n export default Component.extend({\n count: tracked({ value: 0 }),\n \n incrementCount: action(function() {\n this.count++;\n })\n });\n ```\n \n @method did-insert\n @public\n */\n var _default = _exports.default = (0, _modifier.setModifierManager)(() => ({\n capabilities: (0, _modifier.capabilities)('3.22', {\n disableAutoTracking: true\n }),\n createModifier() {},\n installModifier(_state, element, {\n positional: [fn, ...args],\n named\n }) {\n fn(element, args, named);\n },\n updateModifier() {},\n destroyModifier() {}\n }), class DidInsertModifier {});\n});","define(\"@ember/render-modifiers/modifiers/did-update\", [\"exports\", \"@ember/modifier\", \"@embroider/macros/es-compat2\"], function (_exports, _modifier, _esCompat) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.default = void 0;\n const untrack = function () {\n {\n // ember-source@3.27 shipped \"real modules\" by default, so we can just use\n // importSync to get @glimmer/validator directly\n return (0, _esCompat.default)(require(\"@glimmer/validator\")).untrack;\n }\n }();\n\n /**\n The `{{did-update}}` element modifier is activated when any of its arguments\n are updated. It does not run on initial render.\n \n In this example, the `resize` function receives the `textarea` DOM element as its\n first argument and is executed anytime the `@text` argument changes.\n \n ```handlebars\n \n ```\n \n ```js\n export default Component.extend({\n resize(element) {\n element.style.height = `${element.scrollHeight}px`;\n }\n });\n ```\n \n In addition to the `element`, both named and positional arguments are passed to the\n executed function:\n \n ```handlebars\n \n ```\n \n ```js\n export default Component.extend({\n logArguments(element, [first, second], { third }) {\n console.log('element', element);\n console.log('positional args', first, second);\n console.log('names args', third);\n }\n });\n ```\n \n By default, the executed function will be unbound. If you would like to access\n the component context in your function, use the `action` decorator as follows:\n \n ```handlebars\n \n ```\n \n ```js\n export default Component.extend({\n someFunction: action(function(element, [someArg]) {\n // the `this` context will be the component instance\n })\n });\n ```\n \n @method did-update\n @public\n */\n var _default = _exports.default = (0, _modifier.setModifierManager)(() => ({\n capabilities: (0, _modifier.capabilities)('3.22', {\n disableAutoTracking: false\n }),\n createModifier() {\n return {\n element: null\n };\n },\n installModifier(state, element, args) {\n // save element into state bucket\n state.element = element;\n {\n // Consume individual properties to entangle tracking.\n // https://github.com/emberjs/ember.js/issues/19277\n // https://github.com/ember-modifier/ember-modifier/pull/63#issuecomment-815908201\n args.positional.forEach(() => {});\n args.named && Object.values(args.named);\n }\n },\n updateModifier({\n element\n }, args) {\n let [fn, ...positional] = args.positional;\n {\n // Consume individual properties to entangle tracking.\n // https://github.com/emberjs/ember.js/issues/19277\n // https://github.com/ember-modifier/ember-modifier/pull/63#issuecomment-815908201\n args.positional.forEach(() => {});\n args.named && Object.values(args.named);\n untrack(() => {\n fn(element, positional, args.named);\n });\n }\n },\n destroyModifier() {}\n }), class DidUpdateModifier {});\n});","define(\"@ember/render-modifiers/modifiers/will-destroy\", [\"exports\", \"@ember/modifier\"], function (_exports, _modifier) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.default = void 0;\n /**\n The `{{will-destroy}}` element modifier is activated immediately before the element\n is removed from the DOM.\n \n ```handlebars\n
\n {{yield}}\n
\n ```\n \n ```js\n export default Component.extend({\n teardownPlugin(element) {\n // teardown logic here\n }\n });\n ```\n \n By default, the executed function will be unbound. If you would like to access\n the component context in your function, use the `action` decorator as follows:\n \n ```handlebars\n
\n {{yield}}\n
\n ```\n \n ```js\n export default Component.extend({\n teardownPlugin: action(function(element) {\n // the `this` context will be the component instance\n })\n });\n ```\n \n @method will-destroy\n @public\n */\n var _default = _exports.default = (0, _modifier.setModifierManager)(() => ({\n capabilities: (0, _modifier.capabilities)('3.22', {\n disableAutoTracking: true\n }),\n createModifier() {\n return {\n element: null\n };\n },\n installModifier(state, element) {\n state.element = element;\n },\n updateModifier() {},\n destroyModifier({\n element\n }, args) {\n let [fn, ...positional] = args.positional;\n fn(element, positional, args.named);\n }\n }), class WillDestroyModifier {});\n});","define(\"@ember/string/cache\", [\"exports\"], function (_exports) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.default = void 0;\n function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }\n function _toPropertyKey(t) { var i = _toPrimitive(t, \"string\"); return \"symbol\" == typeof i ? i : i + \"\"; }\n function _toPrimitive(t, r) { if (\"object\" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || \"default\"); if (\"object\" != typeof i) return i; throw new TypeError(\"@@toPrimitive must return a primitive value.\"); } return (\"string\" === r ? String : Number)(t); }\n class Cache {\n constructor(limit, func, store) {\n _defineProperty(this, \"size\", 0);\n _defineProperty(this, \"misses\", 0);\n _defineProperty(this, \"hits\", 0);\n this.limit = limit;\n this.func = func;\n this.store = store;\n this.store = store || new Map();\n }\n get(key) {\n let value = this.store.get(key);\n if (this.store.has(key)) {\n this.hits++;\n return this.store.get(key);\n } else {\n this.misses++;\n value = this.set(key, this.func(key));\n }\n return value;\n }\n set(key, value) {\n if (this.limit > this.size) {\n this.size++;\n this.store.set(key, value);\n }\n return value;\n }\n purge() {\n this.store.clear();\n this.size = 0;\n this.hits = 0;\n this.misses = 0;\n }\n }\n _exports.default = Cache;\n});","define(\"@ember/string/index\", [\"exports\", \"@ember/string/cache\"], function (_exports, _cache) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.camelize = camelize;\n _exports.capitalize = capitalize;\n _exports.classify = classify;\n _exports.dasherize = dasherize;\n _exports.decamelize = decamelize;\n _exports.getString = getString;\n _exports.getStrings = getStrings;\n _exports.htmlSafe = htmlSafe;\n _exports.isHTMLSafe = isHTMLSafe;\n _exports.setStrings = setStrings;\n _exports.underscore = underscore;\n _exports.w = w;\n /* eslint-disable no-useless-escape */\n\n /**\n @module @ember/string\n */\n\n // STATE within a module is frowned upon, this exists\n // to support Ember.STRINGS but shield ember internals from this legacy global\n // API.\n let STRINGS = {};\n function setStrings(strings) {\n STRINGS = strings;\n }\n function getStrings() {\n return STRINGS;\n }\n function getString(name) {\n return STRINGS[name];\n }\n const STRING_DASHERIZE_REGEXP = /[ _]/g;\n const STRING_DASHERIZE_CACHE = new _cache.default(1000, key => decamelize(key).replace(STRING_DASHERIZE_REGEXP, '-'));\n const STRING_CAMELIZE_REGEXP_1 = /(\\-|\\_|\\.|\\s)+(.)?/g;\n const STRING_CAMELIZE_REGEXP_2 = /(^|\\/)([A-Z])/g;\n const CAMELIZE_CACHE = new _cache.default(1000, key => key.replace(STRING_CAMELIZE_REGEXP_1, (_match, _separator, chr) => chr ? chr.toUpperCase() : '').replace(STRING_CAMELIZE_REGEXP_2, (match\n /*, separator, chr */) => match.toLowerCase()));\n const STRING_CLASSIFY_REGEXP_1 = /^(\\-|_)+(.)?/;\n const STRING_CLASSIFY_REGEXP_2 = /(.)(\\-|\\_|\\.|\\s)+(.)?/g;\n const STRING_CLASSIFY_REGEXP_3 = /(^|\\/|\\.)([a-z])/g;\n const CLASSIFY_CACHE = new _cache.default(1000, str => {\n const replace1 = (_match, _separator, chr) => chr ? `_${chr.toUpperCase()}` : '';\n const replace2 = (_match, initialChar, _separator, chr) => initialChar + (chr ? chr.toUpperCase() : '');\n const parts = str.split('/');\n for (let i = 0; i < parts.length; i++) {\n parts[i] = parts[i].replace(STRING_CLASSIFY_REGEXP_1, replace1).replace(STRING_CLASSIFY_REGEXP_2, replace2);\n }\n return parts.join('/').replace(STRING_CLASSIFY_REGEXP_3, (match\n /*, separator, chr */) => match.toUpperCase());\n });\n const STRING_UNDERSCORE_REGEXP_1 = /([a-z\\d])([A-Z]+)/g;\n const STRING_UNDERSCORE_REGEXP_2 = /\\-|\\s+/g;\n const UNDERSCORE_CACHE = new _cache.default(1000, str => str.replace(STRING_UNDERSCORE_REGEXP_1, '$1_$2').replace(STRING_UNDERSCORE_REGEXP_2, '_').toLowerCase());\n const STRING_CAPITALIZE_REGEXP = /(^|\\/)([a-z\\u00C0-\\u024F])/g;\n const CAPITALIZE_CACHE = new _cache.default(1000, str => str.replace(STRING_CAPITALIZE_REGEXP, (match\n /*, separator, chr */) => match.toUpperCase()));\n const STRING_DECAMELIZE_REGEXP = /([a-z\\d])([A-Z])/g;\n const DECAMELIZE_CACHE = new _cache.default(1000, str => str.replace(STRING_DECAMELIZE_REGEXP, '$1_$2').toLowerCase());\n /**\n Splits a string into separate units separated by spaces, eliminating any\n empty strings in the process. This is a convenience method for split that\n is mostly useful when applied to the `String.prototype`.\n \n ```javascript\n import { w } from '@ember/string';\n \n w(\"alpha beta gamma\").forEach(function(key) {\n console.log(key);\n });\n \n // > alpha\n // > beta\n // > gamma\n ```\n \n @method w\n @param {String} str The string to split\n @return {Array} array containing the split strings\n @public\n */\n\n function w(str) {\n return str.split(/\\s+/);\n }\n /**\n Converts a camelized string into all lower case separated by underscores.\n \n ```javascript\n import { decamelize } from '@ember/string';\n \n decamelize('innerHTML'); // 'inner_html'\n decamelize('action_name'); // 'action_name'\n decamelize('css-class-name'); // 'css-class-name'\n decamelize('my favorite items'); // 'my favorite items'\n ```\n \n @method decamelize\n @param {String} str The string to decamelize.\n @return {String} the decamelized string.\n @public\n */\n\n function decamelize(str) {\n return DECAMELIZE_CACHE.get(str);\n }\n /**\n Replaces underscores, spaces, or camelCase with dashes.\n \n ```javascript\n import { dasherize } from '@ember/string';\n \n dasherize('innerHTML'); // 'inner-html'\n dasherize('action_name'); // 'action-name'\n dasherize('css-class-name'); // 'css-class-name'\n dasherize('my favorite items'); // 'my-favorite-items'\n dasherize('privateDocs/ownerInvoice'; // 'private-docs/owner-invoice'\n ```\n \n @method dasherize\n @param {String} str The string to dasherize.\n @return {String} the dasherized string.\n @public\n */\n\n function dasherize(str) {\n return STRING_DASHERIZE_CACHE.get(str);\n }\n /**\n Returns the lowerCamelCase form of a string.\n \n ```javascript\n import { camelize } from '@ember/string';\n \n camelize('innerHTML'); // 'innerHTML'\n camelize('action_name'); // 'actionName'\n camelize('css-class-name'); // 'cssClassName'\n camelize('my favorite items'); // 'myFavoriteItems'\n camelize('My Favorite Items'); // 'myFavoriteItems'\n camelize('private-docs/owner-invoice'); // 'privateDocs/ownerInvoice'\n ```\n \n @method camelize\n @param {String} str The string to camelize.\n @return {String} the camelized string.\n @public\n */\n\n function camelize(str) {\n return CAMELIZE_CACHE.get(str);\n }\n /**\n Returns the UpperCamelCase form of a string.\n \n ```javascript\n import { classify } from '@ember/string';\n \n classify('innerHTML'); // 'InnerHTML'\n classify('action_name'); // 'ActionName'\n classify('css-class-name'); // 'CssClassName'\n classify('my favorite items'); // 'MyFavoriteItems'\n classify('private-docs/owner-invoice'); // 'PrivateDocs/OwnerInvoice'\n ```\n \n @method classify\n @param {String} str the string to classify\n @return {String} the classified string\n @public\n */\n\n function classify(str) {\n return CLASSIFY_CACHE.get(str);\n }\n /**\n More general than decamelize. Returns the lower\\_case\\_and\\_underscored\n form of a string.\n \n ```javascript\n import { underscore } from '@ember/string';\n \n underscore('innerHTML'); // 'inner_html'\n underscore('action_name'); // 'action_name'\n underscore('css-class-name'); // 'css_class_name'\n underscore('my favorite items'); // 'my_favorite_items'\n underscore('privateDocs/ownerInvoice'); // 'private_docs/owner_invoice'\n ```\n \n @method underscore\n @param {String} str The string to underscore.\n @return {String} the underscored string.\n @public\n */\n\n function underscore(str) {\n return UNDERSCORE_CACHE.get(str);\n }\n /**\n Returns the Capitalized form of a string\n \n ```javascript\n import { capitalize } from '@ember/string';\n \n capitalize('innerHTML') // 'InnerHTML'\n capitalize('action_name') // 'Action_name'\n capitalize('css-class-name') // 'Css-class-name'\n capitalize('my favorite items') // 'My favorite items'\n capitalize('privateDocs/ownerInvoice'); // 'PrivateDocs/ownerInvoice'\n ```\n \n @method capitalize\n @param {String} str The string to capitalize.\n @return {String} The capitalized string.\n @public\n */\n\n function capitalize(str) {\n return CAPITALIZE_CACHE.get(str);\n }\n /*\n The following are implemented here to give users adding `@ember/string` to\n their projects a useful error message. The `ember-source` implementation of\n `@ember/string` is clobbered by adding this addon, and so the deprecation of\n the import path is not triggered. This error message is intended to help\n users discover what they need to change.\n */\n\n function htmlSafe(str) {\n throw new Error('htmlSafe is not implemented in the `@ember/string` package. Please import from `@ember/template` instead.');\n }\n function isHTMLSafe(str) {\n throw new Error('isHTMLSafe is not implemented in the `@ember/string` package. Please import from `@ember/template` instead.');\n }\n});","define(\"@ember/test-waiters/build-waiter\", [\"exports\", \"@ember/debug\", \"@ember/test-waiters/token\", \"@ember/test-waiters/waiter-manager\"], function (_exports, _debug, _token, _waiterManager) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports._resetWaiterNames = _resetWaiterNames;\n _exports.default = buildWaiter;\n function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }\n function _toPropertyKey(t) { var i = _toPrimitive(t, \"string\"); return \"symbol\" == typeof i ? i : i + \"\"; }\n function _toPrimitive(t, r) { if (\"object\" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || \"default\"); if (\"object\" != typeof i) return i; throw new TypeError(\"@@toPrimitive must return a primitive value.\"); } return (\"string\" === r ? String : Number)(t); }\n const WAITER_NAME_PATTERN = /^[^:]*:?.*/;\n let WAITER_NAMES = true /* DEBUG */ ? new Set() : undefined;\n function _resetWaiterNames() {\n WAITER_NAMES = new Set();\n }\n function getNextToken() {\n return new _token.default();\n }\n class TestWaiterImpl {\n constructor(name, nextToken) {\n _defineProperty(this, \"isRegistered\", false);\n _defineProperty(this, \"items\", new Map());\n _defineProperty(this, \"completedOperationsForTokens\", new WeakMap());\n _defineProperty(this, \"completedOperationsForPrimitives\", new Map());\n this.name = name; // @ts-ignore\n\n this.nextToken = nextToken || getNextToken;\n }\n beginAsync(token = this.nextToken(), label) {\n this._register();\n if (this.items.has(token)) {\n throw new Error(`beginAsync called for ${token} but it is already pending.`);\n }\n let error = new Error();\n this.items.set(token, {\n get stack() {\n return error.stack;\n },\n label\n });\n return token;\n }\n endAsync(token) {\n if (!this.items.has(token) && !this._getCompletedOperations(token).has(token)) {\n throw new Error(`testWaiter.endAsync called with no preceding testWaiter.beginAsync call.\n Test waiter calls should always be paired. This can occur when a test waiter's paired calls are invoked in a non-deterministic order.\n\n See https://github.com/emberjs/ember-test-waiters#keep-beginasyncendasync-in-same-block-scope for more information.`);\n }\n this.items.delete(token); // Mark when a waiter operation has completed so we can distinguish\n // whether endAsync is being called before a prior beginAsync call above.\n\n this._getCompletedOperations(token).set(token, true);\n }\n waitUntil() {\n return this.items.size === 0;\n }\n debugInfo() {\n let result = [];\n this.items.forEach(value => {\n result.push(value);\n });\n return result;\n }\n reset() {\n this.items.clear();\n }\n _register() {\n if (!this.isRegistered) {\n (0, _waiterManager.register)(this);\n this.isRegistered = true;\n }\n }\n _getCompletedOperations(token) {\n let type = typeof token;\n let isFunction = type === 'function';\n let isObject = token !== null && type === 'object';\n let isPrimitive = !isFunction && !isObject;\n return isPrimitive ? this.completedOperationsForPrimitives : this.completedOperationsForTokens;\n }\n }\n class NoopTestWaiter {\n constructor(name) {\n this.name = name;\n }\n beginAsync() {\n return this;\n }\n endAsync() {}\n waitUntil() {\n return true;\n }\n debugInfo() {\n return [];\n }\n reset() {}\n }\n /**\n * Builds and returns a test waiter. The type of the\n * returned waiter is dependent on whether the app or\n * addon is in `DEBUG` mode or not.\n *\n * @public\n *\n * @param name {string} The name of the test waiter\n * @returns {TestWaiter}\n *\n * @example\n *\n * import Component from '@ember/component';\n * import { buildWaiter } from '@ember/test-waiters';\n *\n * if (DEBUG) {\n * let waiter = buildWaiter('friend-waiter');\n * }\n *\n * export default class Friendz extends Component {\n * didInsertElement() {\n * let token = waiter.beginAsync(this);\n *\n * someAsyncWork().then(() => {\n * waiter.endAsync(token);\n * });\n * }\n * }\n */\n\n function buildWaiter(name) {\n if (true /* DEBUG */) {\n (true && (0, _debug.warn)(`The waiter name '${name}' is already in use`, !WAITER_NAMES.has(name), {\n id: '@ember/test-waiters.duplicate-waiter-name'\n }));\n WAITER_NAMES.add(name);\n }\n if (!true /* DEBUG */) {\n return new NoopTestWaiter(name);\n } else {\n (true && (0, _debug.warn)(`You must provide a name that contains a descriptive prefix separated by a colon.\n\n Example: ember-fictitious-addon:some-file\n\n You passed: ${name}`, WAITER_NAME_PATTERN.test(name), {\n id: '@ember/test-waiters.invalid-waiter-name'\n }));\n return new TestWaiterImpl(name);\n }\n }\n});","define(\"@ember/test-waiters/index\", [\"exports\", \"@ember/test-waiters/waiter-manager\", \"@ember/test-waiters/build-waiter\", \"@ember/test-waiters/wait-for-promise\", \"@ember/test-waiters/wait-for\"], function (_exports, _waiterManager, _buildWaiter, _waitForPromise, _waitFor) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n Object.defineProperty(_exports, \"_reset\", {\n enumerable: true,\n get: function () {\n return _waiterManager._reset;\n }\n });\n Object.defineProperty(_exports, \"_resetWaiterNames\", {\n enumerable: true,\n get: function () {\n return _buildWaiter._resetWaiterNames;\n }\n });\n Object.defineProperty(_exports, \"buildWaiter\", {\n enumerable: true,\n get: function () {\n return _buildWaiter.default;\n }\n });\n Object.defineProperty(_exports, \"getPendingWaiterState\", {\n enumerable: true,\n get: function () {\n return _waiterManager.getPendingWaiterState;\n }\n });\n Object.defineProperty(_exports, \"getWaiters\", {\n enumerable: true,\n get: function () {\n return _waiterManager.getWaiters;\n }\n });\n Object.defineProperty(_exports, \"hasPendingWaiters\", {\n enumerable: true,\n get: function () {\n return _waiterManager.hasPendingWaiters;\n }\n });\n Object.defineProperty(_exports, \"register\", {\n enumerable: true,\n get: function () {\n return _waiterManager.register;\n }\n });\n Object.defineProperty(_exports, \"unregister\", {\n enumerable: true,\n get: function () {\n return _waiterManager.unregister;\n }\n });\n Object.defineProperty(_exports, \"waitFor\", {\n enumerable: true,\n get: function () {\n return _waitFor.default;\n }\n });\n Object.defineProperty(_exports, \"waitForPromise\", {\n enumerable: true,\n get: function () {\n return _waitForPromise.default;\n }\n });\n});","define(\"@ember/test-waiters/token\", [\"exports\"], function (_exports) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.default = void 0;\n /**\n * A class representing a test waiter token.\n *\n * @public\n * @class\n */\n class Token {}\n _exports.default = Token;\n});","define(\"@ember/test-waiters/types/index\", [\"exports\"], function (_exports) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n});","define(\"@ember/test-waiters/wait-for-promise\", [\"exports\", \"@ember/test-waiters/build-waiter\"], function (_exports, _buildWaiter) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.default = waitForPromise;\n const PROMISE_WAITER = (0, _buildWaiter.default)('@ember/test-waiters:promise-waiter');\n /**\n * A convenient utility function to simplify waiting for a promise.\n *\n * @public\n * @param promise {Promise | RSVP.Promise} The promise to track async operations for\n * @param label {string} An optional string to identify the promise\n *\n * @example\n *\n * import Component from '@ember/component';\n * import { waitForPromise } from '@ember/test-waiters';\n *\n * export default class Friendz extends Component {\n * didInsertElement() {\n * waitForPromise(new Promise(resolve => {\n * doSomeWork();\n * resolve();\n * }));\n * }\n * }\n */\n\n function waitForPromise(promise, label) {\n let result = promise;\n if (true /* DEBUG */) {\n PROMISE_WAITER.beginAsync(promise, label);\n result = promise.then(value => {\n PROMISE_WAITER.endAsync(promise);\n return value;\n }, error => {\n PROMISE_WAITER.endAsync(promise);\n throw error;\n });\n }\n return result;\n }\n});","define(\"@ember/test-waiters/wait-for\", [\"exports\", \"@ember/test-waiters/wait-for-promise\", \"@ember/test-waiters/build-waiter\"], function (_exports, _waitForPromise, _buildWaiter) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.default = waitFor;\n function waitFor(...args) {\n let isFunction = args.length < 3;\n if (isFunction) {\n let [fn, label] = args;\n return wrapFunction(fn, label);\n } else {\n let [,, descriptor, label] = args;\n if (!true /* DEBUG */) {\n return descriptor;\n }\n let fn = descriptor.value;\n descriptor.value = wrapFunction(fn, label);\n return descriptor;\n }\n }\n function wrapFunction(fn, label) {\n if (!true /* DEBUG */) {\n return fn;\n }\n return function (...args) {\n let result = fn.call(this, ...args);\n if (isThenable(result)) {\n return (0, _waitForPromise.default)(result, label);\n } else if (isGenerator(result)) {\n return waitForGenerator(result, label);\n } else {\n return result;\n }\n };\n }\n function isThenable(maybePromise) {\n let type = typeof maybePromise;\n return (maybePromise !== null && type === 'object' || type === 'function') && typeof maybePromise.then === 'function';\n }\n function isGenerator(maybeGenerator) {\n // Because we don't have Symbol.iterator in IE11\n return typeof maybeGenerator.next === 'function' && typeof maybeGenerator.return === 'function' && typeof maybeGenerator.throw === 'function';\n }\n const GENERATOR_WAITER = (0, _buildWaiter.default)('@ember/test-waiters:generator-waiter');\n function waitForGenerator(generator, label) {\n GENERATOR_WAITER.beginAsync(generator, label);\n let isWaiting = true;\n function stopWaiting() {\n if (isWaiting) {\n GENERATOR_WAITER.endAsync(generator);\n isWaiting = false;\n }\n }\n return {\n next(...args) {\n let hasErrored = true;\n try {\n let val = generator.next(...args);\n hasErrored = false;\n if (val.done) {\n stopWaiting();\n }\n return val;\n } finally {\n // If generator.next() throws, we need to stop waiting. But if we catch\n // and re-throw exceptions, it could move the location from which the\n // uncaught exception is thrown, interfering with the developer\n // debugging experience if they have break-on-exceptions enabled. So we\n // use a boolean flag and a finally block to emulate a catch block.\n if (hasErrored) {\n stopWaiting();\n }\n }\n },\n return(...args) {\n stopWaiting();\n return generator.return(...args);\n },\n throw(...args) {\n stopWaiting();\n return generator.throw(...args);\n }\n };\n }\n});","define(\"@ember/test-waiters/waiter-manager\", [\"exports\", \"ember\", \"@ember/test\"], function (_exports, _ember, _test) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports._reset = _reset;\n _exports.getPendingWaiterState = getPendingWaiterState;\n _exports.getWaiters = getWaiters;\n _exports.hasPendingWaiters = hasPendingWaiters;\n _exports.register = register;\n _exports.unregister = unregister;\n // this ensures that if @ember/test-waiters exists in multiple places in the\n // build output we will still use a single map of waiters (there really should\n // only be one of them, or else `settled` will not work at all)\n const WAITERS = function () {\n const HAS_SYMBOL = typeof Symbol !== 'undefined';\n let symbolName = 'TEST_WAITERS';\n let symbol = HAS_SYMBOL ? Symbol.for(symbolName) : symbolName;\n let global = getGlobal();\n let waiters = global[symbol];\n if (waiters === undefined) {\n waiters = global[symbol] = new Map();\n }\n return waiters;\n }();\n function indexable(input) {\n return input;\n }\n function getGlobal() {\n // eslint-disable-next-line node/no-unsupported-features/es-builtins\n if (typeof globalThis !== 'undefined') return indexable(globalThis);\n if (typeof self !== 'undefined') return indexable(self);\n if (typeof window !== 'undefined') return indexable(window);\n if (typeof global !== 'undefined') return indexable(global);\n throw new Error('unable to locate global object');\n }\n /**\n * Backwards compatibility with legacy waiters system.\n *\n * We want to always register a waiter using the legacy waiter system, as right\n * now if consumers are not on the right version of @ember/test-helpers, using\n * this addon will result in none of these waiters waiting.\n */\n // eslint-disable-next-line ember/new-module-imports\n\n if (_ember.default.Test) {\n (0, _test.registerWaiter)(() => !hasPendingWaiters());\n }\n /**\n * Registers a waiter.\n *\n * @public\n * @param waiter {Waiter} A test waiter instance\n */\n\n function register(waiter) {\n WAITERS.set(waiter.name, waiter);\n }\n /**\n * Un-registers a waiter.\n *\n * @public\n * @param waiter {Waiter} A test waiter instance\n */\n\n function unregister(waiter) {\n WAITERS.delete(waiter.name);\n }\n /**\n * Gets an array of all waiters current registered.\n *\n * @public\n * @returns {Waiter[]}\n */\n\n function getWaiters() {\n let result = [];\n WAITERS.forEach(value => {\n result.push(value);\n });\n return result;\n }\n /**\n * Clears all waiters.\n *\n * @private\n */\n\n function _reset() {\n for (let waiter of getWaiters()) {\n waiter.isRegistered = false;\n }\n WAITERS.clear();\n }\n /**\n * Gets the current state of all waiters. Any waiters whose\n * `waitUntil` method returns false will be considered `pending`.\n *\n * @returns {PendingWaiterState} An object containing a count of all waiters\n * pending and a `waiters` object containing the name of all pending waiters\n * and their debug info.\n */\n\n function getPendingWaiterState() {\n let result = {\n pending: 0,\n waiters: {}\n };\n WAITERS.forEach(waiter => {\n if (!waiter.waitUntil()) {\n result.pending++;\n let debugInfo = waiter.debugInfo();\n result.waiters[waiter.name] = debugInfo || true;\n }\n });\n return result;\n }\n /**\n * Determines if there are any pending waiters.\n *\n * @returns {boolean} `true` if there are pending waiters, otherwise `false`.\n */\n\n function hasPendingWaiters() {\n let state = getPendingWaiterState();\n return state.pending > 0;\n }\n});","define(\"@embroider/macros/es-compat2\", [\"exports\"], function (_exports) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.default = esCompat;\n function esCompat(m) {\n return m?.__esModule ? m : {\n default: m,\n ...m\n };\n }\n});","define(\"@embroider/macros/runtime\", [\"exports\"], function (_exports) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.config = config;\n _exports.each = each;\n _exports.getGlobalConfig = getGlobalConfig;\n _exports.isTesting = isTesting;\n _exports.macroCondition = macroCondition;\n /*\n These are the runtime implementations for the javascript macros that have\n runtime implementations.\n \n Not every macro has a runtime implementation, some only make sense in the\n build and always run there.\n \n Even when we have runtime implementations, we are still careful to emit static\n errors during the build wherever possible, and runtime errors when necessary,\n so that you're not surprised when you switch from runtime-mode to compile-time\n mode.\n */\n\n /*\n CAUTION: in classic builds, this file gets shared by all present copies of\n @embroider/macros. If you want to change its public API, you need to rename it\n and update `pathToRuntime` in ../babel/state.ts to point at it, so that your\n babel plugin and runtime will match.\n */\n\n function each(array) {\n if (!Array.isArray(array)) {\n throw new Error(`the argument to the each() macro must be an array`);\n }\n return array;\n }\n function macroCondition(predicate) {\n return predicate;\n }\n\n // This is here as a compile target for `getConfig` and `getOwnConfig` when\n // we're in runtime mode. This is not public API to call from your own code.\n function config(packageRoot) {\n return runtimeConfig.packages[packageRoot];\n }\n function getGlobalConfig() {\n return runtimeConfig.global;\n }\n function isTesting() {\n let g = runtimeConfig.global;\n let e = g && g['@embroider/macros'];\n return Boolean(e && e.isTesting);\n }\n const runtimeConfig = initializeRuntimeMacrosConfig();\n\n // this exists to be targeted by our babel plugin\n function initializeRuntimeMacrosConfig() {\n return {\n \"packages\": {\n \"/tmp/build_47d11bf8/node_modules/ember-basic-dropdown/node_modules/ember-get-config\": {\n \"modulePrefix\": \"sales-design-ui\"\n }\n },\n \"global\": {\n \"@embroider/macros\": {\n \"isTesting\": false\n }\n }\n };\n }\n function updaterMethods() {\n return {\n config,\n getGlobalConfig,\n setConfig(packageRoot, value) {\n runtimeConfig.packages[packageRoot] = value;\n },\n setGlobalConfig(key, value) {\n runtimeConfig.global[key] = value;\n }\n };\n }\n\n // this is how runtime config can get injected at boot. I'm not sure yet if this\n // should be public API, but we certainly need it internally to set things like\n // the global fastboot.isRunning.\n //\n // consumers of this API push a function onto\n // window._embroider_macros_runtime_config. The function is given four methods\n // which allow it to read and write the per-package and global configs. The\n // reason for allowing both read & write is that merging strategies are up to\n // each consumers -- read first, then merge, then write.\n //\n // For an example user of this API, see where we generate\n // embroider_macros_fastboot_init.js' in @embroider/core.\n let updaters = typeof window !== 'undefined' ? window._embroider_macros_runtime_config : undefined;\n if (updaters) {\n let methods = updaterMethods();\n for (let updater of updaters) {\n updater(methods);\n }\n }\n});","define(\"@embroider/util/ember-private-api\", [\"exports\", \"@embroider/macros/es-compat2\"], function (_exports, _esCompat) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.isCurriedComponentDefinition = void 0;\n _exports.lookupCurriedComponentDefinition = lookupCurriedComponentDefinition;\n let runtime;\n {\n // new enough ember has a real module we can import\n runtime = (0, _esCompat.default)(require(\"@glimmer/runtime\"));\n }\n let {\n isCurriedComponentDefinition,\n CurriedComponentDefinition,\n curry,\n CurriedValue\n } = runtime;\n\n // older embers have isCurriedComponentDefinition, new ones have CurriedValue\n // and instanceof CurriedValue seems good enough.\n _exports.isCurriedComponentDefinition = isCurriedComponentDefinition;\n if (!isCurriedComponentDefinition) {\n _exports.isCurriedComponentDefinition = isCurriedComponentDefinition = function (value) {\n return value instanceof CurriedValue;\n };\n }\n function runtimeResolver(owner) {\n let resolver = owner.lookup('renderer:-dom')._runtimeResolver;\n if (resolver) {\n return resolver;\n }\n let entry = Object.entries(owner.__container__.cache).find(e => e[0].startsWith('template-compiler:main-'));\n if (entry) {\n return entry[1].resolver.resolver;\n }\n throw new Error(`@embroider/util couldn't locate the runtime resolver on this ember version`);\n }\n function lookupCurriedComponentDefinition(name, owner) {\n let resolver = runtimeResolver(owner);\n if (typeof resolver.lookupComponentHandle === 'function') {\n let handle = resolver.lookupComponentHandle(name, contextForLookup(owner));\n if (handle != null) {\n return new CurriedComponentDefinition(resolver.resolve(handle), null);\n }\n }\n\n // here we're doing the same thing the internal currying does, in order to\n // generate a sane error message (even though we don't actually use\n // resolvedDefinition as part of our return value).\n let resolvedDefinition = resolver.lookupComponent(name, owner);\n if (!resolvedDefinition) {\n throw new Error(`Attempted to resolve \\`${name}\\` via ensureSafeComponent, but nothing was found.`);\n }\n return curry(0, name, owner, {\n named: {},\n positional: []\n });\n }\n function contextForLookup(owner) {\n {\n return owner;\n }\n }\n});","define(\"@embroider/util/index\", [\"exports\", \"@ember/debug\", \"@ember/application\", \"@embroider/util/ember-private-api\", \"@ember/component/helper\"], function (_exports, _debug, _application, _emberPrivateApi, _helper) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.EnsureSafeComponentHelper = void 0;\n _exports.ensureSafeComponent = ensureSafeComponent;\n function ensureSafeComponent(value, thingWithOwner) {\n if (typeof value === 'string') {\n return handleString(value, thingWithOwner);\n } else if ((0, _emberPrivateApi.isCurriedComponentDefinition)(value)) {\n return value;\n } else if (value == null) {\n return value;\n } else {\n return handleClass(value, thingWithOwner);\n }\n }\n class EnsureSafeComponentHelper extends _helper.default {\n compute([value]) {\n return ensureSafeComponent(value, this);\n }\n }\n _exports.EnsureSafeComponentHelper = EnsureSafeComponentHelper;\n function handleString(name, thingWithOwner) {\n (true && !(false) && (0, _debug.deprecate)(`You're trying to invoke the component \"${name}\" by passing its name as a string. This won't work under Embroider.`, false, {\n id: 'ensure-safe-component.string',\n url: 'https://github.com/embroider-build/embroider/blob/main/docs/replacing-component-helper.md#when-youre-passing-a-component-to-someone-else',\n until: 'embroider',\n for: '@embroider/util',\n since: '0.27.0'\n }));\n let owner = (0, _application.getOwner)(thingWithOwner);\n return (0, _emberPrivateApi.lookupCurriedComponentDefinition)(name, owner);\n }\n function ensureRegistered(klass, owner) {\n let service = owner.lookup('service:-ensure-registered');\n (true && !(service) && (0, _debug.assert)('Could not lookup private -ensure-registered service', service));\n return service.register(klass, owner);\n }\n function handleClass(klass, thingWithOwner) {\n {\n return klass;\n }\n }\n});","define(\"@embroider/util/services/ensure-registered\", [\"exports\", \"@ember/service\", \"@ember/application\"], function (_exports, _service, _application) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.default = void 0;\n function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }\n function _toPropertyKey(t) { var i = _toPrimitive(t, \"string\"); return \"symbol\" == typeof i ? i : i + \"\"; }\n function _toPrimitive(t, r) { if (\"object\" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || \"default\"); if (\"object\" != typeof i) return i; throw new TypeError(\"@@toPrimitive must return a primitive value.\"); } return (\"string\" === r ? String : Number)(t); }\n class EnsureRegisteredService extends _service.default {\n constructor(...args) {\n super(...args);\n _defineProperty(this, \"classNonces\", new WeakMap());\n _defineProperty(this, \"nonceCounter\", 0);\n }\n register(klass, owner = (0, _application.getOwner)(this)) {\n let nonce = this.classNonces.get(klass);\n if (nonce == null) {\n nonce = `-ensure${this.nonceCounter++}`;\n this.classNonces.set(klass, nonce);\n owner.register(`component:${nonce}`, klass);\n }\n return nonce;\n }\n }\n _exports.default = EnsureRegisteredService;\n});","define(\"@fortawesome/ember-fontawesome/components/fa-icon\", [\"exports\", \"@ember/component\", \"@fortawesome/ember-fontawesome/templates/components/fa-icon\", \"@fortawesome/fontawesome-svg-core\", \"@ember/template\", \"@ember/object\", \"@ember/polyfills\", \"ember-get-config\", \"@ember/debug\"], function (_exports, _component, _faIcon, _fontawesomeSvgCore, _template, _object, _polyfills, _emberGetConfig, _debug) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.default = void 0;\n /*eslint no-console: [\"error\", { allow: [\"warn\"] }] */\n\n function getWithDefault(object, key, defaultValue) {\n let value = (0, _object.get)(object, key);\n if (value === undefined) {\n return defaultValue;\n }\n return value;\n }\n function getConfigOption(key, defaultValue) {\n return getWithDefault(_emberGetConfig.default, `fontawesome.${key}`, defaultValue);\n }\n function objectWithKey(key, value) {\n return Array.isArray(value) && value.length > 0 || !Array.isArray(value) && value ? {\n [key]: value\n } : {};\n }\n function classList() {\n let classes = {\n 'fa-spin': this.spin,\n 'fa-pulse': this.pulse,\n 'fa-fw': this.fixedWidth,\n 'fa-border': this.border,\n 'fa-li': this.listItem,\n 'fa-flip-horizontal': this.flip === 'horizontal' || this.flip === 'both',\n 'fa-flip-vertical': this.flip === 'vertical' || this.flip === 'both',\n [`fa-${this.size}`]: getWithDefault(this, 'size', null) !== null,\n [`fa-rotate-${this.rotation}`]: getWithDefault(this, 'rotation', null) !== null,\n [`fa-pull-${this.pull}`]: getWithDefault(this, 'pull', null) !== null\n };\n return Object.keys(classes).map(key => classes[key] ? key : null).filter(key => key);\n }\n function normalizeIconArgs(prefix, icon) {\n const defaultPrefix = getConfigOption('defaultPrefix', 'fas');\n if (!icon) {\n return {\n prefix: defaultPrefix,\n iconName: null\n };\n }\n if (typeof icon === 'object' && icon.prefix && icon.iconName) {\n return icon;\n }\n if (typeof prefix === 'string' && typeof icon === 'string') {\n return {\n prefix: prefix,\n iconName: icon\n };\n }\n if (typeof icon === 'string') {\n return {\n prefix: defaultPrefix,\n iconName: icon\n };\n }\n }\n const IconComponent = _component.default.extend({\n init() {\n this._super(...arguments);\n if (this.params && this.params.length) {\n (true && !(false) && (0, _debug.deprecate)('Passing the icon as a position param is deprecated and will be removed in v1.0.0.', false, {\n id: '@fortawesome/ember-fontawesome.no-positional-params',\n until: '1.0.0',\n url: 'https://github.com/FortAwesome/ember-fontawesome#template'\n }));\n }\n },\n layout: _faIcon.default,\n tagName: 'svg',\n classNameBindings: ['allClasses'],\n attributeBindings: [\n // attributes watched for mutation\n 'data-prefix', 'data-icon', 'data-fa-transform', 'data-fa-mask', 'data-fa-processed',\n // accessibility attributes\n 'aria-hidden', 'aria-labelledby', 'focusable',\n // svg attributes\n 'role', 'xmlns', 'viewBox', 'safeStyle:style'],\n html: (0, _object.computed)('abstractIcon.children.[]', function () {\n const abstractIcon = this.abstractIcon;\n let newHtml;\n if (!abstractIcon) {\n newHtml = (0, _template.htmlSafe)('');\n } else {\n newHtml = (0, _template.htmlSafe)(abstractIcon.children.reduce((acc, cur) => {\n return `${acc}${(0, _fontawesomeSvgCore.toHtml)(cur)}`;\n }, ''));\n }\n return newHtml;\n }),\n safeStyle: (0, _object.computed)('attributes', function () {\n const attributes = this.attributes;\n const style = getWithDefault(attributes, 'style');\n return style ? (0, _template.htmlSafe)(`${style}`) : undefined;\n }),\n iconOrPositionalParam: (0, _object.computed)('icon', 'params.[]', function () {\n if (this.icon) {\n return this.icon;\n }\n if (this.params && this.params.length) {\n return this.params[0];\n }\n return null;\n }),\n abstractIcon: (0, _object.computed)('border', 'fixedWidth', 'flip', 'icon', 'iconOrPositionalParam', 'listItem', 'mask', 'prefix', 'pull', 'pulse', 'rotation', 'size', 'spin', 'symbol', 'title', 'transform', function () {\n const iconLookup = normalizeIconArgs(this.prefix, this.iconOrPositionalParam);\n const classes = objectWithKey('classes', [...classList.bind(this)()]);\n const transformProp = this.transform;\n const transform = objectWithKey('transform', typeof transformProp === 'string' ? _fontawesomeSvgCore.parse.transform(transformProp) : transformProp);\n const mask = objectWithKey('mask', normalizeIconArgs(null, this.mask));\n const symbol = getWithDefault(this, 'symbol', false);\n let title = getWithDefault(this, 'title', null);\n if (title) {\n title = `${title}`;\n }\n const o = (0, _polyfills.assign)({}, classes, transform, mask, {\n symbol,\n title\n });\n const renderedIcon = (0, _fontawesomeSvgCore.icon)(iconLookup, o);\n if (!renderedIcon) {\n console.warn(`Could not find icon: iconName=${iconLookup.iconName}, prefix=${iconLookup.prefix}`);\n return null;\n }\n return renderedIcon.abstract[0];\n }),\n attributes: (0, _object.computed)('abstractIcon.attributes', function () {\n const abstractIcon = this.abstractIcon;\n return abstractIcon ? abstractIcon.attributes : {};\n }),\n allClasses: (0, _object.computed)('abstractIcon', 'attributes.class', 'class', function () {\n const abstractIcon = this.abstractIcon;\n if (!abstractIcon) {\n return _fontawesomeSvgCore.config.replacementClass;\n }\n const attributes = this.attributes;\n const iconClasses = getWithDefault(attributes, 'class');\n return iconClasses;\n }),\n 'data-prefix': (0, _object.computed)('attributes.data-prefix', function () {\n return getWithDefault(this.attributes, 'data-prefix');\n }),\n 'data-icon': (0, _object.computed)('attributes.data-icon', function () {\n return getWithDefault(this.attributes, 'data-icon');\n }),\n 'data-fa-transform': (0, _object.computed)('attributes.data-fa-transform', function () {\n return getWithDefault(this.attributes, 'data-fa-transform');\n }),\n 'data-fa-mask': (0, _object.computed)('attributes.data-fa-mask', function () {\n return getWithDefault(this.attributes, 'data-fa-mask');\n }),\n 'data-fa-processed': (0, _object.computed)('attributes.data-fa-processed', function () {\n return getWithDefault(this.attributes, 'data-fa-processed');\n }),\n 'aria-hidden': (0, _object.computed)('attributes.aria-hidden', function () {\n return getWithDefault(this.attributes, 'aria-hidden');\n }),\n 'aria-labelledby': (0, _object.computed)('attributes.aria-labelledby', function () {\n return getWithDefault(this.attributes, 'aria-labelledby');\n }),\n 'focusable': (0, _object.computed)('attributes.focusable', function () {\n return getWithDefault(this.attributes, 'focusable');\n }),\n 'role': (0, _object.computed)('attributes.role', function () {\n return getWithDefault(this.attributes, 'role');\n }),\n 'xmlns': (0, _object.computed)('attributes.xmlns', function () {\n return getWithDefault(this.attributes, 'xmlns');\n }),\n 'viewBox': (0, _object.computed)('abstractIcon', 'attributes.viewBox', function () {\n const abstractIcon = this.abstractIcon;\n if (!abstractIcon) {\n return '0 0 448 512';\n }\n return getWithDefault(this.attributes, 'viewBox');\n })\n });\n\n // Enables {{fa-icon 'iconnamehere'}} syntax, while still allowing {{fa-icon icon='iconnamehere'}}\n IconComponent.reopenClass({\n positionalParams: 'params'\n });\n var _default = _exports.default = IconComponent;\n});","define(\"@fortawesome/ember-fontawesome/templates/components/fa-icon\", [\"exports\", \"@ember/template-factory\"], function (_exports, _templateFactory) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.default = void 0;\n var _default = _exports.default = (0, _templateFactory.createTemplateFactory)({\n \"id\": \"TJvKobWq\",\n \"block\": \"[[[1,[30,0,[\\\"html\\\"]]],[1,\\\"\\\\n\\\"]],[],false,[]]\",\n \"moduleName\": \"@fortawesome/ember-fontawesome/templates/components/fa-icon.hbs\",\n \"isStrictMode\": false\n });\n});","define(\"@glimmer/component/-private/base-component-manager\", [\"exports\", \"@glimmer/component/-private/component\"], function (_exports, _component) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.default = BaseComponentManager;\n function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }\n function _toPropertyKey(t) { var i = _toPrimitive(t, \"string\"); return \"symbol\" == typeof i ? i : i + \"\"; }\n function _toPrimitive(t, r) { if (\"object\" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || \"default\"); if (\"object\" != typeof i) return i; throw new TypeError(\"@@toPrimitive must return a primitive value.\"); } return (\"string\" === r ? String : Number)(t); }\n /**\n * This factory function returns a component manager class with common behavior\n * that can be extend to add Glimmer.js- or Ember.js-specific functionality. As\n * these environments converge, the need for two component manager\n * implementations (and thus this factory) should go away.\n */\n function BaseComponentManager(setOwner, getOwner, capabilities) {\n return class {\n static create(attrs) {\n let owner = getOwner(attrs);\n return new this(owner);\n }\n constructor(owner) {\n _defineProperty(this, \"capabilities\", capabilities);\n setOwner(this, owner);\n }\n createComponent(ComponentClass, args) {\n if (true /* DEBUG */) {\n _component.ARGS_SET.set(args.named, true);\n }\n return new ComponentClass(getOwner(this), args.named);\n }\n getContext(component) {\n return component;\n }\n };\n }\n});","define(\"@glimmer/component/-private/component\", [\"exports\", \"@glimmer/component/-private/owner\", \"@glimmer/component/-private/destroyables\"], function (_exports, _owner, _destroyables) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.default = _exports.ARGS_SET = void 0;\n function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }\n function _toPropertyKey(t) { var i = _toPrimitive(t, \"string\"); return \"symbol\" == typeof i ? i : i + \"\"; }\n function _toPrimitive(t, r) { if (\"object\" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || \"default\"); if (\"object\" != typeof i) return i; throw new TypeError(\"@@toPrimitive must return a primitive value.\"); } return (\"string\" === r ? String : Number)(t); }\n // This provides a type-safe `WeakMap`: the getter and setter link the key to a\n // specific value. This is how `WeakMap`s actually behave, but the TS type\n // system does not (yet!) have a good way to capture that for types like\n // `WeakMap` where the type is generic over another generic type (here, `Args`).\n\n // SAFETY: this only holds because we *only* acces this when `DEBUG` is `true`.\n // There is not a great way to connect that data in TS at present.\n let ARGS_SET = _exports.ARGS_SET = void 0;\n if (true /* DEBUG */) {\n _exports.ARGS_SET = ARGS_SET = new WeakMap();\n }\n\n // --- Type utilities for component signatures --- //\n // Type-only \"symbol\" to use with `EmptyObject` below, so that it is *not*\n // equivalent to an empty interface.\n\n /**\n * This provides us a way to have a \"fallback\" which represents an empty object,\n * without the downsides of how TS treats `{}`. Specifically: this will\n * correctly leverage \"excess property checking\" so that, given a component\n * which has no named args, if someone invokes it with any named args, they will\n * get a type error.\n *\n * @internal This is exported so declaration emit works (if it were not emitted,\n * declarations which fall back to it would not work). It is *not* intended for\n * public usage, and the specific mechanics it uses may change at any time.\n * The location of this export *is* part of the public API, because moving it\n * will break existing declarations, but is not legal for end users to import\n * themselves, so ***DO NOT RELY ON IT***.\n */\n\n /** Given a signature `S`, get back the `Args` type. */\n\n /**\n * Given any allowed shorthand form of a signature, desugars it to its full\n * expanded type.\n *\n * @internal This is only exported so we can avoid duplicating it in\n * [Glint](https://github.com/typed-ember/glint) or other such tooling. It is\n * *not* intended for public usage, and the specific mechanics it uses may\n * change at any time. Although the signature produced by is part of Glimmer's\n * public API the existence and mechanics of this specific symbol are *not*,\n * so ***DO NOT RELY ON IT***.\n */\n // The conditional type here is because TS applies conditional types\n // distributively. This means that for union types, checks like `keyof T` get\n // all the keys from all elements of the union, instead of ending up as `never`\n // and then always falling into the `Signature` path instead of falling back to\n // the legacy args handling path.\n\n /**\n * @internal we use this type for convenience internally; inference means users\n * should not normally need to name it\n */\n\n /**\n * The `Component` class defines an encapsulated UI element that is rendered to\n * the DOM. A component is made up of a template and, optionally, this component\n * object.\n *\n * ## Defining a Component\n *\n * To define a component, subclass `Component` and add your own properties,\n * methods and lifecycle hooks:\n *\n * ```ts\n * import Component from '@glimmer/component';\n *\n * export default class extends Component {\n * }\n * ```\n *\n * ## Lifecycle Hooks\n *\n * Lifecycle hooks allow you to respond to changes to a component, such as when\n * it gets created, rendered, updated or destroyed. To add a lifecycle hook to a\n * component, implement the hook as a method on your component subclass.\n *\n * For example, to be notified when Glimmer has rendered your component so you\n * can attach a legacy jQuery plugin, implement the `didInsertElement()` method:\n *\n * ```ts\n * import Component from '@glimmer/component';\n *\n * export default class extends Component {\n * didInsertElement() {\n * $(this.element).pickadate();\n * }\n * }\n * ```\n *\n * ## Data for Templates\n *\n * `Component`s have two different kinds of data, or state, that can be\n * displayed in templates:\n *\n * 1. Arguments\n * 2. Properties\n *\n * Arguments are data that is passed in to a component from its parent\n * component. For example, if I have a `UserGreeting` component, I can pass it\n * a name and greeting to use:\n *\n * ```hbs\n * \n * ```\n *\n * Inside my `UserGreeting` template, I can access the `@name` and `@greeting`\n * arguments that I've been given:\n *\n * ```hbs\n * {{@greeting}}, {{@name}}!\n * ```\n *\n * Arguments are also available inside my component:\n *\n * ```ts\n * console.log(this.args.greeting); // prints \"Olá\"\n * ```\n *\n * Properties, on the other hand, are internal to the component and declared in\n * the class. You can use properties to store data that you want to show in the\n * template, or pass to another component as an argument.\n *\n * ```ts\n * import Component from '@glimmer/component';\n *\n * export default class extends Component {\n * user = {\n * name: 'Robbie'\n * }\n * }\n * ```\n *\n * In the above example, we've defined a component with a `user` property that\n * contains an object with its own `name` property.\n *\n * We can render that property in our template:\n *\n * ```hbs\n * Hello, {{user.name}}!\n * ```\n *\n * We can also take that property and pass it as an argument to the\n * `UserGreeting` component we defined above:\n *\n * ```hbs\n * \n * ```\n *\n * ## Arguments vs. Properties\n *\n * Remember, arguments are data that was given to your component by its parent\n * component, and properties are data your component has defined for itself.\n *\n * You can tell the difference between arguments and properties in templates\n * because arguments always start with an `@` sign (think \"A is for arguments\"):\n *\n * ```hbs\n * {{@firstName}}\n * ```\n *\n * We know that `@firstName` came from the parent component, not the current\n * component, because it starts with `@` and is therefore an argument.\n *\n * On the other hand, if we see:\n *\n * ```hbs\n * {{name}}\n * ```\n *\n * We know that `name` is a property on the component. If we want to know where\n * the data is coming from, we can go look at our component class to find out.\n *\n * Inside the component itself, arguments always show up inside the component's\n * `args` property. For example, if `{{@firstName}}` is `Tom` in the template,\n * inside the component `this.args.firstName` would also be `Tom`.\n */\n class BaseComponent {\n /**\n * Constructs a new component and assigns itself the passed properties. You\n * should not construct new components yourself. Instead, Glimmer will\n * instantiate new components automatically as it renders.\n *\n * @param owner\n * @param args\n */\n constructor(owner, args) {\n /**\n * Named arguments passed to the component from its parent component.\n * They can be accessed in JavaScript via `this.args.argumentName` and in the template via `@argumentName`.\n *\n * Say you have the following component, which will have two `args`, `firstName` and `lastName`:\n *\n * ```hbs\n * \n * ```\n *\n * If you needed to calculate `fullName` by combining both of them, you would do:\n *\n * ```ts\n * didInsertElement() {\n * console.log(`Hi, my full name is ${this.args.firstName} ${this.args.lastName}`);\n * }\n * ```\n *\n * While in the template you could do:\n *\n * ```hbs\n *
Welcome, {{@firstName}} {{@lastName}}!
\n * ```\n */\n _defineProperty(this, \"args\", void 0);\n if (true /* DEBUG */ && !(owner !== null && typeof owner === 'object' && ARGS_SET.has(args))) {\n throw new Error(`You must pass both the owner and args to super() in your component: ${this.constructor.name}. You can pass them directly, or use ...arguments to pass all arguments through.`);\n }\n this.args = args;\n (0, _owner.setOwner)(this, owner);\n }\n get isDestroying() {\n return (0, _destroyables.isDestroying)(this);\n }\n get isDestroyed() {\n return (0, _destroyables.isDestroyed)(this);\n }\n\n /**\n * Called before the component has been removed from the DOM.\n */\n willDestroy() {}\n }\n _exports.default = BaseComponent;\n});","define(\"@glimmer/component/-private/destroyables\", [\"exports\", \"ember\"], function (_exports, _ember) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.isDestroying = _exports.isDestroyed = void 0;\n const isDestroying = _exports.isDestroying = _ember.default._isDestroying;\n const isDestroyed = _exports.isDestroyed = _ember.default._isDestroyed;\n});","define(\"@glimmer/component/-private/ember-component-manager\", [\"exports\", \"ember\", \"@ember/object\", \"@ember/application\", \"@ember/component\", \"@ember/runloop\", \"@glimmer/component/-private/base-component-manager\", \"@glimmer/component/-private/destroyables\"], function (_exports, _ember, _object, _application, _component, _runloop, _baseComponentManager, destroyables) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.default = void 0;\n const {\n setDestroyed,\n setDestroying\n } = destroyables;\n const CAPABILITIES = true // @ts-ignore\n // @ts-ignore\n ? (0, _component.capabilities)('3.13', {\n destructor: true,\n asyncLifecycleCallbacks: false,\n updateHook: false\n }) : (0, _component.capabilities)('3.4', {\n destructor: true,\n asyncLifecycleCallbacks: false\n });\n const scheduledDestroyComponent = true ? undefined : (component, meta) => {\n if (component.isDestroyed) {\n return;\n }\n _ember.default.destroy(component);\n meta.setSourceDestroyed();\n setDestroyed(component);\n };\n const destroy = true ? _ember.default.destroy : component => {\n if (component.isDestroying) {\n return;\n }\n let meta = _ember.default.meta(component);\n meta.setSourceDestroying();\n setDestroying(component);\n (0, _runloop.schedule)('actions', component, component.willDestroy);\n (0, _runloop.schedule)('destroy', void 0, scheduledDestroyComponent, component, meta);\n };\n const registerDestructor = true ? _ember.default._registerDestructor : true ? _ember.default.__loader.require('@glimmer/runtime').registerDestructor : undefined;\n\n /**\n * This component manager runs in Ember.js environments and extends the base component manager to:\n *\n * 1. Properly destroy the component's associated `meta` data structure\n * 2. Schedule destruction using Ember's runloop\n */\n class EmberGlimmerComponentManager extends (0, _baseComponentManager.default)(_application.setOwner, _application.getOwner, CAPABILITIES) {\n createComponent(ComponentClass, args) {\n const component = super.createComponent(ComponentClass, args);\n if (true) {\n registerDestructor(component, () => {\n component.willDestroy();\n });\n }\n return component;\n }\n destroyComponent(component) {\n destroy(component);\n }\n }\n // In Ember 3.12 and earlier, the updateComponent hook was mandatory.\n // As of Ember 3.13, the `args` object is stable and each property of the\n // object participates in the autotrack stack on its own. This means we do not\n // need to set the `args` property on the component instance to invalidate\n // tracked getters that rely on `args`, and therefore don't require the `updateComponent`\n // hook at all.\n if (!true) {\n EmberGlimmerComponentManager.prototype.updateComponent = function updateComponent(component, args) {\n let argSnapshot = args.named;\n if (true /* DEBUG */) {\n argSnapshot = Object.freeze(argSnapshot);\n }\n (0, _object.set)(component, 'args', argSnapshot);\n };\n }\n var _default = _exports.default = EmberGlimmerComponentManager;\n});","define(\"@glimmer/component/-private/owner\", [\"exports\", \"@ember/application\"], function (_exports, _application) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n Object.defineProperty(_exports, \"setOwner\", {\n enumerable: true,\n get: function () {\n return _application.setOwner;\n }\n });\n});","define(\"@glimmer/component/index\", [\"exports\", \"@ember/component\", \"@glimmer/component/-private/ember-component-manager\", \"@glimmer/component/-private/component\"], function (_exports, _component, _emberComponentManager, _component2) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.default = void 0;\n // Hax because the old version of `@types/ember__component` the `1.x` branch\n // uses does not provide any types for `setComponentManager` *and* because we\n // are using a very old version of `setComponentManager` for versions before\n // Ember 3.8.\n\n let GlimmerComponent = _component2.default;\n if (true /* DEBUG */) {\n // Add assertions against using Glimmer.js only APIs\n\n // TODO: Add GlimmerComponent API docs link to these messages once API docs are live\n function throwMethodUseError(methodName) {\n throw new Error(`You attempted to define the '${methodName}' method on a Glimmer Component, but that lifecycle hook does not exist in Ember.js applications, it only exists in Glimmer.js apps. You can rename this method, and you can trigger it using a modifier such as {{did-insert}} from '@ember/render-modifiers': https://github.com/emberjs/ember-render-modifiers.`);\n }\n function throwPropertyUseError(propertyName) {\n throw new Error(`You attempted to access the '${propertyName}' property on a Glimmer Component, but that property does not exist in Ember.js applications, it only exists in Glimmer.js apps. You define a class field with the same name on your component class and it will overwrite this error message, but it will not be used by the framework.`);\n }\n GlimmerComponent = class GlimmerDebugComponent extends GlimmerComponent {\n constructor(owner, args) {\n super(owner, args);\n if (typeof this['didInsertElement'] === 'function') {\n throwMethodUseError('didInsertElement');\n }\n if (typeof this['didUpdate'] === 'function') {\n throwMethodUseError('didUpdate');\n }\n }\n };\n let proto = GlimmerComponent.prototype;\n function defineErrorProp(proto, key, getterMethod) {\n Object.defineProperty(proto, key, {\n get: () => getterMethod(key),\n set(value) {\n Object.defineProperty(this, key, {\n value\n });\n }\n });\n }\n\n // Methods should still throw whenever they are accessed\n defineErrorProp(proto, 'bounds', throwPropertyUseError);\n defineErrorProp(proto, 'element', throwPropertyUseError);\n defineErrorProp(proto, 'debugName', throwPropertyUseError);\n }\n if (true) {\n (0, _component.setComponentManager)(owner => {\n return new _emberComponentManager.default(owner);\n }, GlimmerComponent);\n } else {\n (0, _component.setComponentManager)('glimmer', GlimmerComponent);\n }\n var _default = _exports.default = GlimmerComponent;\n});","define(\"ember-assign-helper/helpers/assign\", [\"exports\", \"@ember/component/helper\"], function (_exports, _helper) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.assign = assign;\n _exports.default = void 0;\n function assign(params) {\n return Object.assign({}, ...params);\n }\n var _default = _exports.default = (0, _helper.helper)(assign);\n});","define(\"ember-basic-dropdown/components/basic-dropdown-content\", [\"exports\", \"@ember/component\", \"@ember/object\", \"@glimmer/component\", \"@glimmer/tracking\", \"@ember/runloop\", \"ember-basic-dropdown/utils/calculate-position\", \"ember-basic-dropdown/utils/scroll-helpers\", \"ember-basic-dropdown/utils/has-moved\", \"ember-modifier\", \"@ember/template-factory\", \"@embroider/macros/runtime\"], function (_exports, _component, _object, _component2, _tracking, _runloop, _calculatePosition, _scrollHelpers, _hasMoved, _emberModifier, _templateFactory, _runtime) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.default = void 0;\n var _class, _descriptor;\n 0; //eaimeta@70e063a35619d71f0,\"ember-cli-htmlbars\",0,\"@ember/object\",0,\"@glimmer/component\",0,\"@glimmer/tracking\",0,\"@ember/runloop\",0,\"ember-basic-dropdown/utils/calculate-position\",0,\"ember-basic-dropdown/utils/scroll-helpers\",0,\"ember-basic-dropdown/utils/has-moved\",0,\"@embroider/macros\",0,\"ember-modifier\",0,\"@ember/component\"eaimeta@70e063a35619d71f\n function _initializerDefineProperty(e, i, r, l) { r && Object.defineProperty(e, i, { enumerable: r.enumerable, configurable: r.configurable, writable: r.writable, value: r.initializer ? r.initializer.call(l) : void 0 }); }\n function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }\n function _toPropertyKey(t) { var i = _toPrimitive(t, \"string\"); return \"symbol\" == typeof i ? i : i + \"\"; }\n function _toPrimitive(t, r) { if (\"object\" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || \"default\"); if (\"object\" != typeof i) return i; throw new TypeError(\"@@toPrimitive must return a primitive value.\"); } return (\"string\" === r ? String : Number)(t); }\n function _applyDecoratedDescriptor(i, e, r, n, l) { var a = {}; return Object.keys(n).forEach(function (i) { a[i] = n[i]; }), a.enumerable = !!a.enumerable, a.configurable = !!a.configurable, (\"value\" in a || a.initializer) && (a.writable = !0), a = r.slice().reverse().reduce(function (r, n) { return n(i, e, r) || r; }, a), l && void 0 !== a.initializer && (a.value = a.initializer ? a.initializer.call(l) : void 0, a.initializer = void 0), void 0 === a.initializer ? (Object.defineProperty(i, e, a), null) : a; }\n function _initializerWarningHelper(r, e) { throw Error(\"Decorating class property failed. Please ensure that transform-class-properties is enabled and runs after the decorators transform.\"); }\n const __COLOCATED_TEMPLATE__ = (0, _templateFactory.createTemplateFactory)(\n /*\n {{! template-lint-disable no-inline-styles }}\n {{#if @dropdown.isOpen}}\n