\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 @constructor\n @extends RESTAdapter\n */\n var JSONAPIAdapter = /*#__PURE__*/function (_RESTAdapter) {\n _inheritsLoose(JSONAPIAdapter, _RESTAdapter);\n\n function JSONAPIAdapter() {\n var _this;\n\n for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n args[_key] = arguments[_key];\n }\n\n _this = _RESTAdapter.call.apply(_RESTAdapter, [this].concat(args)) || this;\n _this.defaultSerializer = '-json-api';\n _this._defaultContentType = 'application/vnd.api+json';\n _this.coalesceFindRequests = false;\n return _this;\n }\n\n var _proto = JSONAPIAdapter.prototype;\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 _proto.ajaxOptions = function ajaxOptions(url, type, options) {\n if (options === void 0) {\n options = {};\n }\n\n var hash = _RESTAdapter.prototype.ajaxOptions.call(this, url, type, options);\n\n hash.headers['Accept'] = hash.headers['Accept'] || 'application/vnd.api+json';\n return hash;\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 @type {boolean}\n */\n ;\n\n _proto.findMany = function findMany(store, type, ids, snapshots) {\n var 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\n _proto.pathForType = function pathForType(modelName) {\n var dasherized = (0, _string.dasherize)(modelName);\n return (0, _emberInflector.pluralize)(dasherized);\n };\n\n _proto.updateRecord = function updateRecord(store, type, snapshot) {\n var data = (0, _private.serializeIntoHash)(store, type, snapshot);\n var url = this.buildURL(type.modelName, snapshot.id, snapshot, 'updateRecord');\n return this.ajax(url, 'PATCH', {\n data: data\n });\n };\n\n return JSONAPIAdapter;\n }(_rest.default);\n\n var _default = JSONAPIAdapter;\n _exports.default = _default;\n});","define(\"@ember-data/adapter/rest\", [\"exports\", \"require\", \"@ember-data/adapter\", \"@ember-data/adapter/error\", \"@ember-data/store/-private\", \"@ember-data/adapter/-private\"], function (_exports, _require, _adapter, _error, _private, _private2) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.fetchOptions = fetchOptions;\n _exports.default = void 0;\n\n var _dec, _class;\n\n function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\n function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }\n\n function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }\n\n function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }\n\n function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) { var desc = {}; Object.keys(descriptor).forEach(function (key) { desc[key] = descriptor[key]; }); desc.enumerable = !!desc.enumerable; desc.configurable = !!desc.configurable; if ('value' in desc || desc.initializer) { desc.writable = true; } desc = decorators.slice().reverse().reduce(function (desc, decorator) { return decorator(target, property, desc) || desc; }, desc); if (context && desc.initializer !== void 0) { desc.value = desc.initializer ? desc.initializer.call(context) : void 0; desc.initializer = undefined; } if (desc.initializer === void 0) { Object.defineProperty(target, property, desc); desc = null; } return desc; }\n\n var UseFetch = (0, _private.symbol)('useFetch');\n var hasJQuery = typeof jQuery !== 'undefined';\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 @constructor\n @extends Adapter\n @uses BuildURLMixin\n */\n\n var RESTAdapter = (_dec = Ember.computed, (_class = /*#__PURE__*/function (_Adapter$extend) {\n _inheritsLoose(RESTAdapter, _Adapter$extend);\n\n function RESTAdapter() {\n var _this;\n\n for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n args[_key] = arguments[_key];\n }\n\n _this = _Adapter$extend.call.apply(_Adapter$extend, [this].concat(args)) || this;\n _this.defaultSerializer = '-rest';\n _this._defaultContentType = 'application/json; charset=utf-8';\n _this.coalesceFindRequests = false;\n _this.maxURLLength = 2048;\n return _this;\n }\n\n var _proto = RESTAdapter.prototype;\n\n /**\n @property useFetch\n @type {Boolean}\n @public\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 */\n _proto.sortQueryParams = function sortQueryParams(obj) {\n var keys = Object.keys(obj);\n var len = keys.length;\n\n if (len < 2) {\n return obj;\n }\n\n var newQueryParams = {};\n var sortedKeys = keys.sort();\n\n for (var i = 0; i < len; i++) {\n newQueryParams[sortedKeys[i]] = obj[sortedKeys[i]];\n }\n\n return newQueryParams;\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 @type {boolean}\n */\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 @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 @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 @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 @param {Store} store\n @param {Model} type\n @param {String} id\n @param {Snapshot} snapshot\n @return {Promise} promise\n */\n _proto.findRecord = function findRecord(store, type, id, snapshot) {\n var url = this.buildURL(type.modelName, id, snapshot, 'findRecord');\n var query = this.buildQuery(snapshot);\n return this.ajax(url, 'GET', {\n data: query\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 @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 ;\n\n _proto.findAll = function findAll(store, type, sinceToken, snapshotRecordArray) {\n var query = this.buildQuery(snapshotRecordArray);\n var url = this.buildURL(type.modelName, null, snapshotRecordArray, 'findAll');\n\n if (sinceToken) {\n query.since = sinceToken;\n }\n\n return this.ajax(url, 'GET', {\n data: query\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 @param {Store} store\n @param {Model} type\n @param {Object} query\n @return {Promise} promise\n */\n ;\n\n _proto.query = function query(store, type, _query) {\n var url = this.buildURL(type.modelName, null, null, 'query', _query);\n\n if (this.sortQueryParams) {\n _query = this.sortQueryParams(_query);\n }\n\n return this.ajax(url, 'GET', {\n data: _query\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 @param {Store} store\n @param {Model} type\n @param {Object} query\n @return {Promise} promise\n */\n ;\n\n _proto.queryRecord = function queryRecord(store, type, query) {\n var url = this.buildURL(type.modelName, null, null, 'queryRecord', query);\n\n if (this.sortQueryParams) {\n query = this.sortQueryParams(query);\n }\n\n return this.ajax(url, 'GET', {\n data: query\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 @param {Store} store\n @param {Model} type\n @param {Array} ids\n @param {Array} snapshots\n @return {Promise} promise\n */\n ;\n\n _proto.findMany = function findMany(store, type, ids, snapshots) {\n var url = this.buildURL(type.modelName, ids, snapshots, 'findMany');\n return this.ajax(url, 'GET', {\n data: {\n ids: ids\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 @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 ;\n\n _proto.findHasMany = function findHasMany(store, snapshot, url, relationship) {\n var id = snapshot.id;\n var type = snapshot.modelName;\n url = this.urlPrefix(url, this.buildURL(type, id, snapshot, 'findHasMany'));\n return this.ajax(url, 'GET');\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 @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 ;\n\n _proto.findBelongsTo = function findBelongsTo(store, snapshot, url, relationship) {\n var id = snapshot.id;\n var type = snapshot.modelName;\n url = this.urlPrefix(url, this.buildURL(type, id, snapshot, 'findBelongsTo'));\n return this.ajax(url, 'GET');\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 @param {Store} store\n @param {Model} type\n @param {Snapshot} snapshot\n @return {Promise} promise\n */\n ;\n\n _proto.createRecord = function createRecord(store, type, snapshot) {\n var url = this.buildURL(type.modelName, null, snapshot, 'createRecord');\n var data = (0, _private2.serializeIntoHash)(store, type, snapshot);\n return this.ajax(url, 'POST', {\n data: data\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 @param {Store} store\n @param {Model} type\n @param {Snapshot} snapshot\n @return {Promise} promise\n */\n ;\n\n _proto.updateRecord = function updateRecord(store, type, snapshot) {\n var data = (0, _private2.serializeIntoHash)(store, type, snapshot, {});\n var id = snapshot.id;\n var url = this.buildURL(type.modelName, id, snapshot, 'updateRecord');\n return this.ajax(url, 'PUT', {\n data: data\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 @param {Store} store\n @param {Model} type\n @param {Snapshot} snapshot\n @return {Promise} promise\n */\n ;\n\n _proto.deleteRecord = function deleteRecord(store, type, snapshot) {\n var id = snapshot.id;\n return this.ajax(this.buildURL(type.modelName, id, snapshot, 'deleteRecord'), 'DELETE');\n };\n\n _proto._stripIDFromURL = function _stripIDFromURL(store, snapshot) {\n var url = this.buildURL(snapshot.modelName, snapshot.id, snapshot);\n var expandedURL = url.split('/'); // 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\n var lastSegment = expandedURL[expandedURL.length - 1];\n var id = snapshot.id;\n\n if (decodeURIComponent(lastSegment) === id) {\n expandedURL[expandedURL.length - 1] = '';\n } else if (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\n return expandedURL.join('/');\n } // http://stackoverflow.com/questions/417142/what-is-the-maximum-length-of-a-url-in-different-browsers\n ;\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 @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 _proto.groupRecordsForFindMany = function groupRecordsForFindMany(store, snapshots) {\n var groups = new Map();\n var adapter = this;\n var maxURLLength = this.maxURLLength;\n snapshots.forEach(function (snapshot) {\n var baseUrl = adapter._stripIDFromURL(store, snapshot);\n\n if (!groups.has(baseUrl)) {\n groups.set(baseUrl, []);\n }\n\n groups.get(baseUrl).push(snapshot);\n });\n\n function splitGroupToFitInUrl(group, maxURLLength, paramNameLength) {\n var idsSize = 0;\n\n var baseUrl = adapter._stripIDFromURL(store, group[0]);\n\n var splitGroups = [[]];\n group.forEach(function (snapshot) {\n var additionalLength = encodeURIComponent(snapshot.id).length + paramNameLength;\n\n if (baseUrl.length + idsSize + additionalLength >= maxURLLength) {\n idsSize = 0;\n splitGroups.push([]);\n }\n\n idsSize += additionalLength;\n var lastGroupIndex = splitGroups.length - 1;\n splitGroups[lastGroupIndex].push(snapshot);\n });\n return splitGroups;\n }\n\n var groupsArray = [];\n groups.forEach(function (group, key) {\n var paramNameLength = '&ids%5B%5D='.length;\n var splitGroups = splitGroupToFitInUrl(group, maxURLLength, paramNameLength);\n splitGroups.forEach(function (splitGroup) {\n return groupsArray.push(splitGroup);\n });\n });\n return groupsArray;\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 @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 ;\n\n _proto.handleResponse = function 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(payload.errors);\n }\n\n var errors = this.normalizeErrorResponse(status, headers, payload);\n var detailedMessage = this.generatedDetailedMessage(status, headers, payload, requestData);\n\n switch (status) {\n case 401:\n return new _error.UnauthorizedError(errors, detailedMessage);\n\n case 403:\n return new _error.ForbiddenError(errors, detailedMessage);\n\n case 404:\n return new _error.NotFoundError(errors, detailedMessage);\n\n case 409:\n return new _error.ConflictError(errors, detailedMessage);\n\n default:\n if (status >= 500) {\n return new _error.ServerError(errors, detailedMessage);\n }\n\n }\n\n return new _error.default(errors, detailedMessage);\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 @param {Number} status\n @param {Object} headers\n @param {Object} payload\n @return {Boolean}\n */\n ;\n\n _proto.isSuccess = function isSuccess(status, headers, payload) {\n return status >= 200 && status < 300 || status === 304;\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 @param {Number} status\n @param {Object} headers\n @param {Object} payload\n @return {Boolean}\n */\n ;\n\n _proto.isInvalid = function isInvalid(status, headers, payload) {\n return status === 422;\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 ;\n\n _proto.ajax = function ajax(url, type, options) {\n var adapter = this;\n var requestData = {\n url: url,\n method: type\n };\n var hash = adapter.ajaxOptions(url, type, options);\n\n if (this.useFetch) {\n var _response;\n\n return this._fetchRequest(hash).then(function (response) {\n _response = response;\n return (0, _private2.determineBodyPromise)(response, requestData);\n }).then(function (payload) {\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 });\n }\n\n return new Ember.RSVP.Promise(function (resolve, reject) {\n hash.success = function (payload, textStatus, jqXHR) {\n var response = ajaxSuccessHandler(adapter, payload, jqXHR, requestData);\n Ember.run.join(null, resolve, response);\n };\n\n hash.error = function (jqXHR, textStatus, errorThrown) {\n var error = ajaxErrorHandler(adapter, jqXHR, errorThrown, requestData);\n Ember.run.join(null, reject, error);\n };\n\n adapter._ajax(hash);\n }, 'DS: RESTAdapter#ajax ' + type + ' to ' + url);\n }\n /**\n @method _ajaxRequest\n @private\n @param {Object} options jQuery ajax options to be used for the ajax request\n */\n ;\n\n _proto._ajaxRequest = function _ajaxRequest(options) {\n jQuery.ajax(options);\n };\n\n _proto._fetchRequest = function _fetchRequest(options) {\n var fetchFunction = (0, _private2.fetch)();\n\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\n _proto._ajax = function _ajax(options) {\n if (this.useFetch) {\n this._fetchRequest(options);\n } else if (true\n /* DEPRECATE_NAJAX */\n && Ember.get(this, 'fastboot.isFastBoot')) {\n this._najaxRequest(options);\n } else {\n this._ajaxRequest(options);\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 ;\n\n _proto.ajaxOptions = function ajaxOptions(url, method, options) {\n options = Ember.assign({\n url: url,\n method: method,\n type: method\n }, options);\n var headers = Ember.get(this, 'headers');\n\n if (headers !== undefined) {\n options.headers = Ember.assign({}, headers, options.headers);\n } else if (!options.headers) {\n options.headers = {};\n }\n\n var contentType = options.contentType || this._defaultContentType;\n\n if (this.useFetch) {\n if (options.data && options.type !== 'GET') {\n if (!options.headers['Content-Type'] && !options.headers['content-type']) {\n options.headers['content-type'] = contentType;\n }\n }\n\n options = fetchOptions(options, 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 (options.data && options.type !== 'GET') {\n options = Ember.assign(options, {\n contentType: contentType\n });\n }\n\n options = _ajaxOptions(options, this);\n }\n\n options.url = this._ajaxURL(options.url);\n return options;\n };\n\n _proto._ajaxURL = function _ajaxURL(url) {\n if (Ember.get(this, 'fastboot.isFastBoot')) {\n var httpRegex = /^https?:\\/\\//;\n var protocolRelativeRegex = /^\\/\\//;\n var protocol = Ember.get(this, 'fastboot.request.protocol');\n var host = Ember.get(this, 'fastboot.request.host');\n\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\n return url;\n }\n /**\n @method parseErrorResponse\n @private\n @param {String} responseText\n @return {Object}\n */\n ;\n\n _proto.parseErrorResponse = function parseErrorResponse(responseText) {\n var json = responseText;\n\n try {\n json = JSON.parse(responseText);\n } catch (e) {// ignored\n }\n\n return json;\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 ;\n\n _proto.normalizeErrorResponse = function normalizeErrorResponse(status, headers, payload) {\n if (payload && typeof payload === 'object' && payload.errors) {\n return payload.errors;\n } else {\n return [{\n status: \"\" + status,\n title: 'The backend responded with an error',\n detail: \"\" + payload\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 ;\n\n _proto.generatedDetailedMessage = function generatedDetailedMessage(status, headers, payload, requestData) {\n var shortenedPayload;\n var payloadContentType = headers['content-type'] || 'Empty Content-Type';\n\n if (payloadContentType === 'text/html' && payload.length > 250) {\n shortenedPayload = '[Omitted Lengthy HTML]';\n } else {\n shortenedPayload = payload;\n }\n\n var requestDescription = requestData.method + ' ' + requestData.url;\n var payloadDescription = 'Payload (' + payloadContentType + ')';\n return ['Ember Data Request ' + requestDescription + ' returned a ' + status, payloadDescription, shortenedPayload].join('\\n');\n }\n /**\n @method buildQuery\n @since 2.5.0\n @public\n @param {Snapshot} snapshot\n @return {Object}\n */\n ;\n\n _proto.buildQuery = function buildQuery(snapshot) {\n var query = {};\n\n if (snapshot) {\n var include = snapshot.include;\n\n if (include) {\n query.include = include;\n }\n }\n\n return query;\n };\n\n _createClass(RESTAdapter, [{\n key: \"fastboot\",\n get: function get() {\n // Avoid computed property override deprecation in fastboot as suggested by:\n // https://deprecations.emberjs.com/v3.x/#toc_computed-property-override\n if (this._fastboot) {\n return this._fastboot;\n }\n\n return this._fastboot = Ember.getOwner(this).lookup('service:fastboot');\n },\n set: function set(value) {\n return this._fastboot = value;\n }\n }]);\n\n return RESTAdapter;\n }(_adapter.default.extend(_adapter.BuildURLMixin)), (_applyDecoratedDescriptor(_class.prototype, \"fastboot\", [_dec], Object.getOwnPropertyDescriptor(_class.prototype, \"fastboot\"), _class.prototype)), _class));\n\n function ajaxSuccess(adapter, payload, requestData, responseData) {\n var response;\n\n try {\n response = adapter.handleResponse(responseData.status, responseData.headers, payload, requestData);\n } catch (error) {\n return Ember.RSVP.Promise.reject(error);\n }\n\n if (response && response.isAdapterError) {\n return Ember.RSVP.Promise.reject(response);\n } else {\n return response;\n }\n }\n\n function ajaxError(adapter, payload, requestData, responseData) {\n var error;\n\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\n return error;\n } // Adapter abort error to include any relevent info, e.g. request/response:\n\n\n function handleAbort(requestData, responseData) {\n var method = requestData.method,\n url = requestData.url,\n errorThrown = requestData.errorThrown;\n var status = responseData.status;\n var msg = \"Request failed: \" + method + \" \" + url + \" \" + (errorThrown || '');\n var errors = [{\n title: 'Adapter Error',\n detail: msg.trim(),\n status: status\n }];\n return new _error.AbortError(errors);\n } //From http://stackoverflow.com/questions/280634/endswith-in-javascript\n\n\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\n function fetchSuccessHandler(adapter, payload, response, requestData) {\n var responseData = fetchResponseData(response);\n return ajaxSuccess(adapter, payload, requestData, responseData);\n }\n\n function fetchErrorHandler(adapter, payload, response, errorThrown, requestData) {\n var responseData = fetchResponseData(response);\n\n if (responseData.status === 200 && payload instanceof Error) {\n responseData.errorThrown = payload;\n payload = responseData.errorThrown.payload;\n } else {\n responseData.errorThrown = errorThrown;\n payload = adapter.parseErrorResponse(payload);\n }\n\n return ajaxError(adapter, payload, requestData, responseData);\n }\n\n function ajaxSuccessHandler(adapter, payload, jqXHR, requestData) {\n var responseData = ajaxResponseData(jqXHR);\n return ajaxSuccess(adapter, payload, requestData, responseData);\n }\n\n function ajaxErrorHandler(adapter, jqXHR, errorThrown, requestData) {\n var responseData = ajaxResponseData(jqXHR);\n responseData.errorThrown = errorThrown;\n var payload = adapter.parseErrorResponse(jqXHR.responseText);\n\n if (true\n /* DEBUG */\n ) {\n var 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 var validJSONString = !(responseData.textStatus === 'parsererror' && payload === '');\n (true && Ember.warn(message, validJSONString, {\n id: 'ds.adapter.returned-empty-string-as-JSON'\n }));\n }\n\n return ajaxError(adapter, payload, requestData, responseData);\n }\n\n function fetchResponseData(response) {\n return {\n status: response.status,\n textStatus: response.textStatus,\n headers: headersToObject(response.headers)\n };\n }\n\n function ajaxResponseData(jqXHR) {\n return {\n status: jqXHR.status,\n textStatus: jqXHR.statusText,\n headers: (0, _private2.parseResponseHeaders)(jqXHR.getAllResponseHeaders())\n };\n }\n\n function headersToObject(headers) {\n var headersObject = {};\n\n if (headers) {\n headers.forEach(function (value, key) {\n return headersObject[key] = value;\n });\n }\n\n return headersObject;\n }\n /**\n * Helper function that translates the options passed to `jQuery.ajax` into a format that `fetch` expects.\n * @param {Object} _options\n * @param {Adapter} adapter\n * @returns {Object}\n */\n\n\n function fetchOptions(options, adapter) {\n options.credentials = options.credentials || 'same-origin';\n\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) {\n // Test if there are already query params in the url (mimics jQuey.ajax).\n var queryParamDelimiter = options.url.indexOf('?') > -1 ? '&' : '?';\n options.url += \"\" + queryParamDelimiter + (0, _private2.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\n return options;\n }\n\n function _ajaxOptions(options, adapter) {\n options.dataType = 'json';\n options.context = adapter;\n\n if (options.data && options.type !== 'GET') {\n options.data = JSON.stringify(options.data);\n }\n\n options.beforeSend = function (xhr) {\n Object.keys(options.headers).forEach(function (key) {\n return xhr.setRequestHeader(key, options.headers[key]);\n });\n };\n\n return options;\n }\n\n if (true\n /* DEPRECATE_NAJAX */\n ) {\n /**\n @method _najaxRequest\n @private\n @param {Object} options jQuery ajax options to be used for the najax request\n */\n RESTAdapter.prototype._najaxRequest = function (options) {\n if (typeof najax !== 'undefined') {\n najax(options);\n } else {\n throw new Error('najax does not seem to be defined in your app. Did you override it via `addOrOverrideSandboxGlobals` in the fastboot server?');\n }\n };\n\n Object.defineProperty(RESTAdapter.prototype, 'useFetch', {\n get: function get() {\n if (typeof this[UseFetch] === 'boolean') {\n return this[UseFetch];\n } // Mixin validates all properties. Might not have it in the container yet\n\n\n var ENV = Ember.getOwner(this) ? Ember.getOwner(this).resolveRegistration('config:environment') : {}; // TODO: https://github.com/emberjs/data/issues/6093\n\n var jQueryIntegrationDisabled = ENV && ENV.EmberENV && ENV.EmberENV._JQUERY_INTEGRATION === false;\n var shouldUseFetch;\n\n if (jQueryIntegrationDisabled) {\n shouldUseFetch = true;\n } else if (typeof najax !== 'undefined') {\n if ((0, _require.has)('fetch')) {\n (true && !(false) && Ember.deprecate('You have ember-fetch and jquery installed. To use ember-fetch instead of najax, set `useFetch = true` in your adapter. In 4.0, ember-data will default to ember-fetch instead of najax when both ember-fetch and jquery are installed in FastBoot.', false, {\n id: 'ember-data:najax-fallback',\n until: '4.0'\n }));\n } else {\n (true && !(false) && Ember.deprecate('In 4.0, ember-data will default to ember-fetch instead of najax in FastBoot. It is recommended that you install ember-fetch or similar fetch polyfill in FastBoot and set `useFetch = true` in your adapter.', false, {\n id: 'ember-data:najax-fallback',\n until: '4.0'\n }));\n }\n\n shouldUseFetch = false;\n } else if (hasJQuery) {\n shouldUseFetch = false;\n } else {\n shouldUseFetch = true;\n }\n\n (0, _private.addSymbol)(this, UseFetch, shouldUseFetch);\n return shouldUseFetch;\n },\n set: function set(value) {\n (0, _private.addSymbol)(this, UseFetch, value);\n return value;\n }\n });\n } else {\n Object.defineProperty(RESTAdapter.prototype, 'useFetch', {\n value: function value() {\n return true;\n },\n configurable: true\n });\n }\n\n var _default = RESTAdapter;\n _exports.default = _default;\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 /**\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=REQUEST_SERVICE ember build\n * ```\n *\n * *Example activating multiple feature flags*\n *\n * ```js\n * EMBER_DATA_FEATURE_OVERRIDE=REQUEST_SERVICE,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 /*\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 = {\n SAMPLE_FEATURE_FLAG: null,\n RECORD_DATA_ERRORS: null,\n RECORD_DATA_STATE: null,\n IDENTIFIERS: true,\n REQUEST_SERVICE: null,\n CUSTOM_MODEL_CLASS: null,\n FULL_LINKS_ON_RELATIONSHIPS: true,\n RECORD_ARRAY_MANAGER_IDENTIFIERS: true,\n REMOVE_RECORD_ARRAY_MANAGER_LEGACY_COMPAT: null\n };\n _exports.default = _default;\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.REMOVE_RECORD_ARRAY_MANAGER_LEGACY_COMPAT = _exports.RECORD_ARRAY_MANAGER_IDENTIFIERS = _exports.FULL_LINKS_ON_RELATIONSHIPS = _exports.CUSTOM_MODEL_CLASS = _exports.IDENTIFIERS = _exports.REQUEST_SERVICE = _exports.RECORD_DATA_STATE = _exports.RECORD_DATA_ERRORS = _exports.SAMPLE_FEATURE_FLAG = _exports.FEATURES = void 0;\n var ENV = typeof EmberDataENV !== 'undefined' && EmberDataENV !== null ? EmberDataENV : {};\n\n function featureValue(value) {\n if (ENV.ENABLE_OPTIONAL_FEATURES && value === null) {\n return true;\n }\n\n return value;\n }\n\n var FEATURES = Ember.assign({}, _defaultFeatures.default, ENV.FEATURES);\n _exports.FEATURES = FEATURES;\n var SAMPLE_FEATURE_FLAG = featureValue(FEATURES.SAMPLE_FEATURE_FLAG);\n _exports.SAMPLE_FEATURE_FLAG = SAMPLE_FEATURE_FLAG;\n var RECORD_DATA_ERRORS = featureValue(FEATURES.RECORD_DATA_ERRORS);\n _exports.RECORD_DATA_ERRORS = RECORD_DATA_ERRORS;\n var RECORD_DATA_STATE = featureValue(FEATURES.RECORD_DATA_STATE);\n _exports.RECORD_DATA_STATE = RECORD_DATA_STATE;\n var REQUEST_SERVICE = featureValue(FEATURES.REQUEST_SERVICE);\n _exports.REQUEST_SERVICE = REQUEST_SERVICE;\n var IDENTIFIERS = featureValue(FEATURES.IDENTIFIERS);\n _exports.IDENTIFIERS = IDENTIFIERS;\n var CUSTOM_MODEL_CLASS = featureValue(FEATURES.CUSTOM_MODEL_CLASS);\n _exports.CUSTOM_MODEL_CLASS = CUSTOM_MODEL_CLASS;\n var FULL_LINKS_ON_RELATIONSHIPS = featureValue(FEATURES.FULL_LINKS_ON_RELATIONSHIPS);\n _exports.FULL_LINKS_ON_RELATIONSHIPS = FULL_LINKS_ON_RELATIONSHIPS;\n var RECORD_ARRAY_MANAGER_IDENTIFIERS = featureValue(FEATURES.RECORD_ARRAY_MANAGER_IDENTIFIERS);\n _exports.RECORD_ARRAY_MANAGER_IDENTIFIERS = RECORD_ARRAY_MANAGER_IDENTIFIERS;\n var REMOVE_RECORD_ARRAY_MANAGER_LEGACY_COMPAT = featureValue(FEATURES.REMOVE_RECORD_ARRAY_MANAGER_LEGACY_COMPAT);\n _exports.REMOVE_RECORD_ARRAY_MANAGER_LEGACY_COMPAT = REMOVE_RECORD_ARRAY_MANAGER_LEGACY_COMPAT;\n});","define(\"@ember-data/debug/index\", [\"exports\", \"@ember/string\", \"@ember-data/debug/setup\"], function (_exports, _string, _setup) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.default = void 0;\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 = Ember.DataAdapter.extend({\n store: Ember.inject.service('store'),\n\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: function 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: function _nameToClass(type) {\n return Ember.get(this, 'store').modelFor(type);\n },\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 @public\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: function watchModelTypes(typesAdded, typesUpdated) {\n var _this = this;\n\n var store = Ember.get(this, 'store');\n var __createRecordData = store._createRecordData;\n var _releaseMethods = [];\n var discoveredTypes = (0, _setup.typesMapFor)(store); // Add any models that were added during initialization of the app, before the inspector was opened\n\n discoveredTypes.forEach(function (_, type) {\n _this.watchTypeIfUnseen(store, discoveredTypes, type, typesAdded, typesUpdated, _releaseMethods);\n }); // Overwrite _createRecordData so newly added models will get added to the list\n\n store._createRecordData = function (identifier) {\n _this.watchTypeIfUnseen(store, discoveredTypes, identifier.type, typesAdded, typesUpdated, _releaseMethods);\n\n return __createRecordData.call(store, identifier);\n };\n\n var release = function release() {\n _releaseMethods.forEach(function (fn) {\n return fn();\n });\n\n store._createRecordData = __createRecordData; // 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\n discoveredTypes.forEach(function (value, key) {\n discoveredTypes.set(key, false);\n });\n\n _this.releaseMethods.removeObject(release);\n };\n\n this.releaseMethods.pushObject(release);\n return release;\n },\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 * @param {store} store\n * @internal\n * @param {Map} discoveredTypes\n * @param {String} type\n * @param {Function} typesAdded\n * @param {Function} typesUpdated\n * @param {Array} releaseMethods\n */\n watchTypeIfUnseen: function watchTypeIfUnseen(store, discoveredTypes, type, typesAdded, typesUpdated, releaseMethods) {\n if (discoveredTypes.get(type) !== true) {\n var klass = store.modelFor(type);\n var wrapped = this.wrapModelType(klass, type);\n releaseMethods.push(this.observeModelType(type, typesUpdated));\n typesAdded([wrapped]);\n discoveredTypes.set(type, true);\n }\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: function columnNameToDesc(name) {\n return (0, _string.capitalize)((0, _string.underscore)(name).replace(/_/g, ' ').trim());\n },\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: function columnsForType(typeClass) {\n var _this2 = this;\n\n var columns = [{\n name: 'id',\n desc: 'Id'\n }];\n var count = 0;\n var self = this;\n Ember.get(typeClass, 'attributes').forEach(function (meta, name) {\n if (count++ > self.attributeLimit) {\n return false;\n }\n\n var desc = _this2.columnNameToDesc(name);\n\n columns.push({\n name: name,\n desc: desc\n });\n });\n return columns;\n },\n\n /**\n Fetches all loaded records for a given type\n @method getRecords\n @internal\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: function getRecords(modelClass, modelName) {\n if (arguments.length < 2) {\n // Legacy Ember.js < 1.13 support\n var containerKey = modelClass._debugContainerKey;\n\n if (containerKey) {\n var match = containerKey.match(/model:(.*)/);\n\n if (match !== null) {\n modelName = match[1];\n }\n }\n }\n\n (true && !(!!modelName) && Ember.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 /**\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: function getRecordColumnValues(record) {\n var _this3 = this;\n\n var count = 0;\n var columnValues = {\n id: Ember.get(record, 'id')\n };\n record.eachAttribute(function (key) {\n if (count++ > _this3.attributeLimit) {\n return false;\n }\n\n columnValues[key] = Ember.get(record, key);\n });\n return columnValues;\n },\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: function getRecordKeywords(record) {\n var keywords = [];\n var keys = Ember.A(['id']);\n record.eachAttribute(function (key) {\n return keys.push(key);\n });\n keys.forEach(function (key) {\n return keywords.push(Ember.get(record, key));\n });\n return keywords;\n },\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: function 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 /**\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: function getRecordColor(record) {\n var color = 'black';\n\n if (record.get('isNew')) {\n color = 'green';\n } else if (record.get('hasDirtyAttributes')) {\n color = 'blue';\n }\n\n return color;\n },\n\n /**\n Observes all relevant properties and re-sends the wrapped record\n when a change occurs\n @method observeRecord\n @internal\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: function observeRecord(record, recordUpdated) {\n var releaseMethods = Ember.A();\n var keysToObserve = Ember.A(['id', 'isNew', 'hasDirtyAttributes']);\n record.eachAttribute(function (key) {\n return keysToObserve.push(key);\n });\n var adapter = this;\n keysToObserve.forEach(function (key) {\n var handler = function handler() {\n recordUpdated(adapter.wrapRecord(record));\n };\n\n Ember.addObserver(record, key, handler);\n releaseMethods.push(function () {\n Ember.removeObserver(record, key, handler);\n });\n });\n\n var release = function release() {\n releaseMethods.forEach(function (fn) {\n return fn();\n });\n };\n\n return release;\n }\n });\n\n _exports.default = _default;\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.typesMapFor = typesMapFor;\n _exports.default = void 0;\n var StoreTypesMap = new WeakMap();\n\n function typesMapFor(store) {\n var typesMap = StoreTypesMap.get(store);\n\n if (typesMap === undefined) {\n typesMap = new Map();\n StoreTypesMap.set(store, typesMap);\n }\n\n return typesMap;\n } // override _createRecordData to add the known models to the typesMap\n\n\n var __createRecordData = _store.default.prototype._createRecordData;\n\n _store.default.prototype._createRecordData = function (identifier) {\n var typesMap = typesMapFor(this);\n\n if (!typesMap.has(identifier.type)) {\n typesMap.set(identifier.type, false);\n }\n\n return __createRecordData.call(this, identifier);\n };\n\n var _default = {\n name: '@ember-data/data-adapter',\n initialize: function initialize() {}\n };\n _exports.default = _default;\n});","define('@ember-data/model/-private', ['exports', '@ember-data/store/-private', '@ember-data/store'], function (exports, Private, store) { 'use strict';\n\n function isElementDescriptor(args) {\n var maybeTarget = args[0],\n maybeKey = args[1],\n maybeDesc = args[2];\n return (// Ensure we have the right number of args\n args.length === 3 && ( // Make sure the target is a class or object (prototype)\n typeof maybeTarget === 'function' || typeof maybeTarget === 'object' && maybeTarget !== null) && // Make sure the key is a string\n typeof maybeKey === 'string' && ( // Make sure the descriptor is the right shape\n typeof maybeDesc === 'object' && maybeDesc !== null && 'enumerable' in maybeDesc && 'configurable' in maybeDesc || // TS compatibility\n maybeDesc === undefined)\n );\n }\n function computedMacroWithOptionalParams(fn) {\n {\n return function () {\n for (var _len = arguments.length, maybeDesc = new Array(_len), _key = 0; _key < _len; _key++) {\n maybeDesc[_key] = arguments[_key];\n }\n\n return isElementDescriptor(maybeDesc) ? fn().apply(void 0, maybeDesc) : fn.apply(void 0, maybeDesc);\n };\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 var defaultValue = options.defaultValue;\n ( !(typeof defaultValue !== 'object' || defaultValue === null) && Ember.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 function hasValue(internalModel, key) {\n return Private.recordDataFor(internalModel).hasAttr(key);\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 Transform.extend({\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\n\n function attr(type, options) {\n if (typeof type === 'object') {\n options = type;\n type = undefined;\n } else {\n options = options || {};\n }\n\n var meta = {\n type: type,\n isAttribute: true,\n kind: 'attribute',\n options: options\n };\n return Ember.computed({\n get: function 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 attr on \" + this.constructor.toString());\n }\n }\n\n var internalModel = this._internalModel;\n\n if (hasValue(internalModel, key)) {\n return internalModel.getAttributeValue(key);\n } else {\n return getDefaultValue(this, options, key);\n }\n },\n set: function 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 attr on \" + this.constructor.toString());\n }\n }\n\n return this._internalModel.setDirtyAttribute(key, value);\n }\n }).meta(meta);\n }\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\n function belongsTo(modelName, options) {\n var opts, userEnteredModelName;\n\n if (typeof modelName === 'object') {\n opts = modelName;\n userEnteredModelName = undefined;\n } else {\n opts = options;\n userEnteredModelName = modelName;\n }\n\n if (typeof userEnteredModelName === 'string') {\n userEnteredModelName = store.normalizeModelName(userEnteredModelName);\n }\n\n ( !(typeof userEnteredModelName === 'string' || typeof userEnteredModelName === 'undefined') && Ember.assert('The first argument to belongsTo must be a string representing a model type key, not an instance of ' + Ember.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 var meta = {\n type: userEnteredModelName,\n isRelationship: true,\n options: opts,\n kind: 'belongsTo',\n name: 'Belongs To',\n key: null\n };\n return Ember.computed({\n get: function 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\n if (Object.prototype.hasOwnProperty.call(opts, 'serialize')) {\n ( Ember.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\n if (Object.prototype.hasOwnProperty.call(opts, 'embedded')) {\n ( Ember.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\n return this._internalModel.getBelongsTo(key);\n },\n set: function 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\n this._internalModel.setDirtyBelongsTo(key, value);\n\n return this._internalModel.getBelongsTo(key);\n }\n }).meta(meta);\n }\n\n var belongsTo$1 = computedMacroWithOptionalParams(belongsTo);\n\n /**\n @module @ember-data/model\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\n function hasMany(type, options) {\n if (typeof type === 'object') {\n options = type;\n type = undefined;\n }\n\n ( !(typeof type === 'string' || typeof type === 'undefined') && Ember.assert(\"The first argument to hasMany must be a string representing a model type key, not an instance of \" + Ember.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\n if (typeof type === 'string') {\n type = store.normalizeModelName(type);\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\n\n var meta = {\n type: type,\n options: options,\n isRelationship: true,\n kind: 'hasMany',\n name: 'Has Many',\n key: null\n };\n return Ember.computed({\n get: function 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\n return this._internalModel.getHasMany(key);\n },\n set: function 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\n var internalModel = this._internalModel;\n internalModel.setDirtyHasMany(key, records);\n return internalModel.getHasMany(key);\n }\n }).meta(meta);\n }\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 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 @extends ArrayProxy\n @uses Evented\n */\n\n var Errors = Ember.ArrayProxy.extend(Private.DeprecatedEvented, {\n /**\n Register with target handler\n @method _registerHandlers\n @private\n */\n _registerHandlers: function _registerHandlers(becameInvalid, becameValid) {\n this._registeredHandlers = {\n becameInvalid: becameInvalid,\n becameValid: becameValid\n };\n },\n\n /**\n @property errorsByAttributeName\n @type {MapWithDefault}\n @private\n */\n errorsByAttributeName: Ember.computed(function () {\n return new Map();\n }),\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 @param {String} attribute\n @return {Array}\n */\n errorsFor: function errorsFor(attribute) {\n var map = Ember.get(this, 'errorsByAttributeName');\n var errors = map.get(attribute);\n\n if (errors === undefined) {\n errors = Ember.A();\n map.set(attribute, errors);\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\n\n Ember.get(errors, '[]');\n return errors;\n },\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 @type {Array}\n */\n messages: Ember.computed.mapBy('content', 'message'),\n\n /**\n @property content\n @type {Array}\n @private\n */\n content: Ember.computed(function () {\n return Ember.A();\n }),\n\n /**\n @method unknownProperty\n @private\n */\n unknownProperty: function unknownProperty(attribute) {\n var errors = this.errorsFor(attribute);\n\n if (errors.length === 0) {\n return undefined;\n }\n\n return errors;\n },\n\n /**\n Total number of errors.\n @property length\n @type {Number}\n @readOnly\n */\n\n /**\n @property isEmpty\n @type {Boolean}\n @readOnly\n */\n isEmpty: Ember.computed.not('length').readOnly(),\n\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('password');\n // =>\n // [\n // { attribute: 'username', message: 'This field is required' },\n // ]\n ```\n @method add\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: function add(attribute, messages) {\n var wasEmpty = Ember.get(this, 'isEmpty');\n\n this._add(attribute, messages);\n\n if (wasEmpty && !Ember.get(this, 'isEmpty')) {\n this._registeredHandlers && this._registeredHandlers.becameInvalid();\n\n if ( this._has('becameInvalid')) {\n this.trigger('becameInvalid');\n }\n }\n },\n\n /**\n Adds error messages to a given attribute without sending event.\n @method _add\n @private\n */\n _add: function _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 /**\n @method _findOrCreateMessages\n @private\n */\n _findOrCreateMessages: function _findOrCreateMessages(attribute, messages) {\n var errors = this.errorsFor(attribute);\n var messagesArray = Ember.makeArray(messages);\n\n var _messages = new Array(messagesArray.length);\n\n for (var i = 0; i < messagesArray.length; i++) {\n var message = messagesArray[i];\n var err = errors.findBy('message', message);\n\n if (err) {\n _messages[i] = err;\n } else {\n _messages[i] = {\n attribute: attribute,\n message: message\n };\n }\n }\n\n return _messages;\n },\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 @param {string} member - the property name of an attribute or relationship\n */\n remove: function remove(attribute) {\n if (Ember.get(this, 'isEmpty')) {\n return;\n }\n\n this._remove(attribute);\n\n if (Ember.get(this, 'isEmpty')) {\n this._registeredHandlers && this._registeredHandlers.becameValid();\n\n if ( this._has('becameValid')) {\n this.trigger('becameValid');\n }\n }\n },\n\n /**\n Removes all error messages from the given attribute without sending event.\n @method _remove\n @private\n */\n _remove: function _remove(attribute) {\n if (Ember.get(this, 'isEmpty')) {\n return;\n }\n\n var content = this.rejectBy('attribute', attribute);\n Ember.get(this, 'content').setObjects(content); // Although errorsByAttributeName.delete is technically enough to sync errors state, we also\n // must mutate the array as well for autotracking\n\n var errors = this.errorsFor(attribute);\n\n for (var 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\n Ember.get(this, 'errorsByAttributeName').delete(attribute);\n this.notifyPropertyChange(attribute);\n this.notifyPropertyChange('length');\n },\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 remove\n */\n clear: function clear() {\n if (Ember.get(this, 'isEmpty')) {\n return;\n }\n\n this._clear();\n\n this._registeredHandlers && this._registeredHandlers.becameValid();\n\n if ( this._has('becameValid')) {\n this.trigger('becameValid');\n }\n },\n\n /**\n Removes all error messages.\n to the record.\n @method _clear\n @private\n */\n _clear: function _clear() {\n var _this = this;\n\n if (Ember.get(this, 'isEmpty')) {\n return;\n }\n\n var errorsByAttributeName = Ember.get(this, 'errorsByAttributeName');\n var attributes = [];\n errorsByAttributeName.forEach(function (_, attribute) {\n attributes.push(attribute);\n });\n errorsByAttributeName.clear();\n attributes.forEach(function (attribute) {\n _this.notifyPropertyChange(attribute);\n });\n Ember.ArrayProxy.prototype.clear.call(this);\n },\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 @param {String} attribute\n @return {Boolean} true if there some errors on given attribute\n */\n has: function has(attribute) {\n return this.errorsFor(attribute).length > 0;\n }\n });\n\n /**\n @module @ember-data/model\n */\n\n var relationshipsDescriptor = Ember.computed(function () {\n var map = new Map();\n var relationshipsByName = Ember.get(this, 'relationshipsByName'); // Loop through each computed property on the class\n\n relationshipsByName.forEach(function (desc) {\n var type = desc.type;\n\n if (!map.has(type)) {\n map.set(type, []);\n }\n\n map.get(type).push(desc);\n });\n return map;\n }).readOnly();\n var relatedTypesDescriptor = Ember.computed(function () {\n var _this = this;\n\n var parentModelName = this.modelName;\n var types = Ember.A(); // Loop through each computed property on the class,\n // and create an array of the unique types involved\n // in relationships\n\n this.eachComputedProperty(function (name, meta) {\n if (meta.isRelationship) {\n meta.key = name;\n var modelName = Private.typeForRelationshipMeta(meta);\n ( !(modelName) && Ember.assert(\"You specified a hasMany (\" + meta.type + \") on \" + parentModelName + \" but \" + meta.type + \" was not found.\", modelName));\n\n if (!types.includes(modelName)) {\n ( !(!!modelName) && Ember.assert(\"Trying to sideload \" + name + \" on \" + _this.toString() + \" but the type doesn't exist.\", !!modelName));\n types.push(modelName);\n }\n }\n });\n return types;\n }).readOnly();\n var relationshipsObjectDescriptor = Ember.computed(function () {\n var relationships = Object.create(null);\n var modelName = this.modelName;\n this.eachComputedProperty(function (name, meta) {\n if (meta.isRelationship) {\n meta.key = name;\n meta.name = name;\n meta.parentModelName = modelName;\n relationships[name] = Private.relationshipFromMeta(meta);\n }\n });\n return relationships;\n });\n var relationshipsByNameDescriptor = Ember.computed(function () {\n var map = new Map();\n var rels = Ember.get(this, 'relationshipsObject');\n var relationships = Object.keys(rels);\n\n for (var i = 0; i < relationships.length; i++) {\n var key = relationships[i];\n var value = rels[key];\n map.set(value.key, value);\n }\n\n return map;\n }).readOnly();\n\n var changeProperties = Ember.changeProperties;\n\n function findPossibleInverses(type, inverseType, name, relationshipsSoFar) {\n var possibleRelationships = relationshipsSoFar || [];\n var relationshipMap = Ember.get(inverseType, 'relationships');\n\n if (!relationshipMap) {\n return possibleRelationships;\n }\n\n var relationshipsForType = relationshipMap.get(type.modelName);\n var relationships = Array.isArray(relationshipsForType) ? relationshipsForType.filter(function (relationship) {\n var optionsForRelationship = inverseType.metaForProperty(relationship.name).options;\n\n if (!optionsForRelationship.inverse && optionsForRelationship.inverse !== null) {\n return true;\n }\n\n return name === optionsForRelationship.inverse;\n }) : null;\n\n if (relationships) {\n possibleRelationships.push.apply(possibleRelationships, relationships);\n } //Recurse to support polymorphism\n\n\n if (type.superclass) {\n findPossibleInverses(type.superclass, inverseType, name, possibleRelationships);\n }\n\n return possibleRelationships;\n }\n\n var retrieveFromCurrentState = Ember.computed('currentState', function (key) {\n return Ember.get(this._internalModel.currentState, key);\n }).readOnly();\n var isValidRecordData = Ember.computed('errors.length', function (key) {\n return !(this.get('errors.length') > 0);\n }).readOnly();\n var isValid = retrieveFromCurrentState;\n var isDeletedCP;\n\n {\n isDeletedCP = retrieveFromCurrentState;\n }\n\n var isNewCP;\n\n {\n isNewCP = retrieveFromCurrentState;\n }\n\n var adapterError;\n\n {\n adapterError = null;\n }\n\n var isError;\n\n {\n isError = false;\n }\n\n var isReloading;\n\n {\n isReloading = false;\n }\n /**\n @class Model\n @module @ember-data/model\n @extends EmberObject\n @uses EmberData.DeprecatedEvented\n */\n\n\n var Model = Ember.Object.extend(Private.DeprecatedEvented, {\n init: function init() {\n\n this._super.apply(this, arguments);\n\n {\n if (!this._internalModel) {\n throw new Ember.Error('You should not call `create` on a model. Instead, call `store.createRecord` with the attributes you would like to set.');\n }\n }\n },\n _notifyNetworkChanges: function _notifyNetworkChanges() {\n var _this2 = this;\n\n {\n ['isValid'].forEach(function (key) {\n return _this2.notifyPropertyChange(key);\n });\n }\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 @type {Boolean}\n @readOnly\n */\n isEmpty: retrieveFromCurrentState,\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 @type {Boolean}\n @readOnly\n */\n isLoading: retrieveFromCurrentState,\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 @type {Boolean}\n @readOnly\n */\n isLoaded: retrieveFromCurrentState,\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 @type {Boolean}\n @readOnly\n */\n hasDirtyAttributes: Ember.computed('currentState.isDirty', function () {\n return this.get('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 @type {Boolean}\n @readOnly\n */\n isSaving: retrieveFromCurrentState,\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 @type {Boolean}\n @readOnly\n */\n isDeleted: isDeletedCP,\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 @type {Boolean}\n @readOnly\n */\n isNew: isNewCP,\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 @type {Boolean}\n @readOnly\n */\n isValid: isValid,\n _markInvalidRequestAsClean: function _markInvalidRequestAsClean() {\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 @type {String}\n @readOnly\n */\n dirtyType: retrieveFromCurrentState,\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 @type {Boolean}\n @readOnly\n */\n isError: isError,\n _markErrorRequestAsClean: function _markErrorRequestAsClean() {\n this._errorRequests = [];\n this._lastError = null;\n\n this._notifyNetworkChanges();\n },\n\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 @type {Boolean}\n @readOnly\n */\n isReloading: isReloading,\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 @type {String}\n */\n\n /**\n @property currentState\n @private\n @type {Object}\n */\n currentState: Private.RootState.empty,\n // defined here to avoid triggering setUnknownProperty\n\n /**\n @property _internalModel\n @private\n @type {Object}\n */\n _internalModel: null,\n // defined here to avoid triggering setUnknownProperty\n\n /**\n @property recordData\n @private\n @type undefined (reserved)\n */\n // will be defined here to avoid triggering setUnknownProperty\n\n /**\n @property store\n */\n store: null,\n // defined here to avoid triggering setUnknownProperty\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 @type {Errors}\n */\n errors: Ember.computed(function () {\n var _this3 = this;\n\n var errors = Errors.create();\n\n errors._registerHandlers(function () {\n _this3.send('becameInvalid');\n }, function () {\n _this3.send('becameValid');\n });\n\n return errors;\n }).readOnly(),\n invalidErrorsChanged: function invalidErrorsChanged(jsonApiErrors) {\n },\n _addErrorMessageToAttribute: function _addErrorMessageToAttribute(attribute, message) {\n this.get('errors')._add(attribute, message);\n },\n _clearErrorMessages: function _clearErrorMessages() {\n this.get('errors')._clear();\n },\n\n /**\n This property holds the `AdapterError` object with which\n last adapter operation was rejected.\n @property adapterError\n @type {AdapterError}\n */\n adapterError: adapterError,\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 @param {Object} options\n @return {Object} an object whose values are primitive JSON values only\n */\n serialize: function serialize(options) {\n return this._internalModel.createSnapshot().serialize(options);\n },\n\n /**\n Fired when the record is ready to be interacted with,\n that is either loaded from the server or created locally.\n @event ready\n */\n ready: null,\n\n /**\n Fired when the record is loaded from the server.\n @event didLoad\n */\n didLoad: null,\n\n /**\n Fired when the record is updated.\n @event didUpdate\n */\n didUpdate: null,\n\n /**\n Fired when a new record is commited to the server.\n @event didCreate\n */\n didCreate: null,\n\n /**\n Fired when the record is deleted.\n @event didDelete\n */\n didDelete: null,\n\n /**\n Fired when the record becomes invalid.\n @event becameInvalid\n */\n becameInvalid: null,\n\n /**\n Fired when the record enters the error state.\n @event becameError\n */\n becameError: null,\n\n /**\n Fired when the record is rolled back.\n @event rolledBack\n */\n rolledBack: null,\n //TODO Do we want to deprecate these?\n\n /**\n @method send\n @private\n @param {String} name\n @param {Object} context\n */\n send: function send(name, context) {\n return this._internalModel.send(name, context);\n },\n\n /**\n @method transitionTo\n @private\n @param {String} name\n */\n transitionTo: function transitionTo(name) {\n return this._internalModel.transitionTo(name);\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 */\n deleteRecord: function deleteRecord() {\n this._internalModel.deleteRecord();\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 @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: function destroyRecord(options) {\n this.deleteRecord();\n return this.save(options);\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 */\n unloadRecord: function unloadRecord() {\n if (this.isDestroyed) {\n return;\n }\n\n this._internalModel.unloadRecord();\n },\n\n /**\n @method _notifyProperties\n @private\n */\n _notifyProperties: function _notifyProperties(keys) {\n var _this4 = this;\n\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(function () {\n var key;\n\n for (var i = 0, length = keys.length; i < length; i++) {\n key = keys[i];\n\n _this4.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 @return {Object} an object, whose keys are changed properties,\n and value is an [oldProp, newProp] array.\n */\n changedAttributes: function 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 */\n rollbackAttributes: function rollbackAttributes() {\n this._internalModel.rollbackAttributes();\n },\n\n /*\n @method _createSnapshot\n @private\n */\n _createSnapshot: function _createSnapshot() {\n return this._internalModel.createSnapshot();\n },\n toStringExtension: function 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 @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: function save(options) {\n var _this5 = this;\n\n return Private.PromiseObject.create({\n promise: this._internalModel.save(options).then(function () {\n return _this5;\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 @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: function reload(options) {\n var _this6 = this;\n\n var wrappedAdapterOptions;\n\n if (typeof options === 'object' && options !== null && options.adapterOptions) {\n wrappedAdapterOptions = {\n adapterOptions: options.adapterOptions\n };\n }\n\n return Private.PromiseObject.create({\n promise: this._internalModel.reload(wrappedAdapterOptions).then(function () {\n return _this6;\n })\n });\n },\n attr: function attr() {\n ( Ember.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 @param {String} name of the relationship\n @since 2.5.0\n @return {BelongsToReference} reference for this relationship\n */\n belongsTo: function 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 @param {String} name of the relationship\n @since 2.5.0\n @return {HasManyReference} reference for this relationship\n */\n hasMany: function hasMany(name) {\n return this._internalModel.referenceFor('hasMany', name);\n },\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 _debugInfo: function _debugInfo() {\n var attributes = ['id'];\n var relationships = {};\n var expensiveProperties = [];\n this.eachAttribute(function (name, meta) {\n return attributes.push(name);\n });\n var groups = [{\n name: 'Attributes',\n properties: attributes,\n expand: true\n }];\n this.eachRelationship(function (name, relationship) {\n var properties = relationships[relationship.kind];\n\n if (properties === undefined) {\n properties = relationships[relationship.kind] = [];\n groups.push({\n name: relationship.kind,\n properties: properties,\n expand: true\n });\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 notifyBelongsToChange: function notifyBelongsToChange(key) {\n this.notifyPropertyChange(key);\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 @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: function eachRelationship(callback, binding) {\n this.constructor.eachRelationship(callback, binding);\n },\n relationshipFor: function relationshipFor(name) {\n return Ember.get(this.constructor, 'relationshipsByName').get(name);\n },\n inverseFor: function inverseFor(key) {\n return this.constructor.inverseFor(key, this._internalModel.store);\n },\n notifyHasManyAdded: function notifyHasManyAdded(key) {\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 this.notifyPropertyChange(key);\n },\n eachAttribute: function eachAttribute(callback, binding) {\n this.constructor.eachAttribute(callback, binding);\n }\n });\n\n {\n /**\n Override the default event firing from Ember.Evented to\n also call methods with the given name.\n @method trigger\n @private\n @param {String} name\n */\n Model.reopen({\n trigger: function trigger(name) {\n {\n var fn = this[name];\n\n if (typeof fn === 'function') {\n var length = arguments.length;\n var args = new Array(length - 1);\n\n for (var i = 1; i < length; i++) {\n args[i - 1] = arguments[i];\n }\n\n fn.apply(this, args);\n }\n }\n\n var _hasEvent = this._has(name) ;\n\n if (_hasEvent) {\n this._super.apply(this, arguments);\n }\n }\n });\n }\n\n {\n /**\n Use [JSONSerializer](JSONSerializer.html) to\n get the JSON representation of a record.\n `toJSON` 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 toJSON\n @param {Object} options\n @return {Object} A JSON representation of the object.\n */\n Model.reopen({\n toJSON: function toJSON(options) {\n // container is for lazy transform lookups\n ( Ember.deprecate(\"Called the built-in `toJSON` on the record \\\"\" + this.constructor.modelName + \":\" + this.id + \"\\\". The built-in `toJSON` method on instances of classes extending `Model` is deprecated. For more information see the link below.\", false, {\n id: 'ember-data:model.toJSON',\n until: '4.0',\n url: 'https://deprecations.emberjs.com/ember-data/v3.x#toc_record-toJSON'\n }));\n\n var serializer = this._internalModel.store.serializerFor('-default');\n\n var snapshot = this._internalModel.createSnapshot();\n\n return serializer.serialize(snapshot, options);\n }\n });\n }\n\n var ID_DESCRIPTOR = {\n configurable: false,\n set: function set(id) {\n var normalizedId = Private.coerceId(id);\n\n if (normalizedId !== null) {\n this._internalModel.setId(normalizedId);\n }\n },\n get: function get() {\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;\n }\n }\n\n Ember.get(this._internalModel, '_tag');\n return this._internalModel.id;\n }\n };\n Object.defineProperty(Model.prototype, 'id', ID_DESCRIPTOR);\n\n {\n var lookupDescriptor = function lookupDescriptor(obj, keyName) {\n var current = obj;\n\n do {\n var descriptor = Object.getOwnPropertyDescriptor(current, keyName);\n\n if (descriptor !== undefined) {\n return descriptor;\n }\n\n current = Object.getPrototypeOf(current);\n } while (current !== null);\n\n return null;\n };\n\n var isBasicDesc = function isBasicDesc(desc) {\n return !desc || !desc.get && !desc.set && desc.enumerable === true && desc.writable === true && desc.configurable === true;\n };\n\n var isDefaultEmptyDescriptor = function isDefaultEmptyDescriptor(obj, keyName) {\n var instanceDesc = lookupDescriptor(obj, keyName);\n return isBasicDesc(instanceDesc) && lookupDescriptor(obj.constructor, keyName) === null;\n };\n\n var lookupDeprecations;\n\n var _deprecatedLifecycleMethods;\n\n {\n var INSTANCE_DEPRECATIONS = new WeakMap();\n _deprecatedLifecycleMethods = ['becameError', 'becameInvalid', 'didCreate', 'didDelete', 'didLoad', 'didUpdate', 'ready', 'rolledBack'];\n\n lookupDeprecations = function lookupInstanceDeprecations(instance) {\n var deprecations = INSTANCE_DEPRECATIONS.get(instance);\n\n if (!deprecations) {\n deprecations = new Set();\n INSTANCE_DEPRECATIONS.set(instance, deprecations);\n }\n\n return deprecations;\n };\n }\n\n Model.reopen({\n init: function init() {\n var _this7 = this;\n\n this._super.apply(this, arguments);\n\n {\n this._getDeprecatedEventedInfo = function () {\n return _this7._internalModel.modelName + \"#\" + _this7.id;\n };\n }\n\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\n if (!isDefaultEmptyDescriptor(this, 'currentState') || this.get('currentState') !== this._internalModel.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\n var idDesc = lookupDescriptor(this, 'id');\n\n if (idDesc.get !== ID_DESCRIPTOR.get) {\n throw new Ember.Error(\"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 var lifecycleDeprecations = lookupDeprecations(this.constructor);\n\n _deprecatedLifecycleMethods.forEach(function (methodName) {\n if (typeof _this7[methodName] === 'function' && !lifecycleDeprecations.has(methodName)) {\n ( Ember.deprecate(\"You defined a `\" + methodName + \"` method for \" + _this7.constructor.toString() + \" but lifecycle events for models have been deprecated.\", false, {\n id: 'ember-data:record-lifecycle-event-methods',\n until: '4.0',\n url: 'https://deprecations.emberjs.com/ember-data/v3.x#toc_record-lifecycle-event-methods'\n }));\n lifecycleDeprecations.add(methodName);\n }\n });\n }\n }\n });\n }\n\n Model.reopenClass({\n isModel: true,\n\n /**\n Create should only ever be called by the store. To create an instance of a\n `Model` in a dirty state use `store.createRecord`.\n To create instances of `Model` in a clean state, use `store.push`\n @method create\n @private\n @static\n */\n\n /**\n Represents the model's class name as a string. This can be used to look up the model's class name through\n `Store`'s modelFor method.\n `modelName` is generated for you by Ember Data. It will be a lowercased, dasherized string.\n For example:\n ```javascript\n store.modelFor('post').modelName; // 'post'\n store.modelFor('blog-post').modelName; // 'blog-post'\n ```\n The most common place you'll want to access `modelName` is in your serializer's `payloadKeyFromModelName` method. For example, to change payload\n keys to underscore (instead of dasherized), you might use the following code:\n ```javascript\n import RESTSerializer from '@ember-data/serializer/rest';\n import { underscore } from '@ember/string';\n export default const PostSerializer = RESTSerializer.extend({\n payloadKeyFromModelName(modelName) {\n return underscore(modelName);\n }\n });\n ```\n @property modelName\n @type String\n @readonly\n @static\n */\n modelName: null,\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 @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 typeForRelationship: function typeForRelationship(name, store) {\n var relationship = Ember.get(this, 'relationshipsByName').get(name);\n return relationship && store.modelFor(relationship.type);\n },\n inverseMap: Ember.computed(function () {\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 @static\n @param {String} name the name of the relationship\n @param {Store} store\n @return {Object} the inverse relationship, or null\n */\n inverseFor: function inverseFor(name, store) {\n var inverseMap = Ember.get(this, 'inverseMap');\n\n if (inverseMap[name]) {\n return inverseMap[name];\n } else {\n var inverse = this._findInverseFor(name, store);\n\n inverseMap[name] = inverse;\n return inverse;\n }\n },\n //Calculate the inverse, ignoring the cache\n _findInverseFor: function _findInverseFor(name, store) {\n var inverseType = this.typeForRelationship(name, store);\n\n if (!inverseType) {\n return null;\n }\n\n var propertyMeta = this.metaForProperty(name); //If inverse is manually specified to be null, like `comments: hasMany('message', { inverse: null })`\n\n var options = propertyMeta.options;\n\n if (options.inverse === null) {\n return null;\n }\n\n var inverseName, inverseKind, inverse, inverseOptions; //If inverse is specified manually, return the inverse\n\n if (options.inverse) {\n inverseName = options.inverse;\n inverse = Ember.get(inverseType, 'relationshipsByName').get(inverseName);\n ( !(!Ember.isNone(inverse)) && Ember.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.\", !Ember.isNone(inverse))); // TODO probably just return the whole inverse here\n\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 ( Ember.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\n var possibleRelationships = findPossibleInverses(this, inverseType, name);\n\n if (possibleRelationships.length === 0) {\n return null;\n }\n\n var filteredRelationships = possibleRelationships.filter(function (possibleRelationship) {\n var optionsForRelationship = inverseType.metaForProperty(possibleRelationship.name).options;\n return name === optionsForRelationship.inverse;\n });\n ( !(filteredRelationships.length < 2) && Ember.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\n if (filteredRelationships.length === 1) {\n possibleRelationships = filteredRelationships;\n }\n\n ( !(possibleRelationships.length === 1) && Ember.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\n ( !(!inverseOptions || inverseOptions.inverse !== null) && Ember.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 = get(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 @static\n @type Map\n @readOnly\n */\n relationships: relationshipsDescriptor,\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 = get(Blog, 'relationshipNames');\n relationshipNames.hasMany;\n //=> ['users', 'posts']\n relationshipNames.belongsTo;\n //=> ['owner']\n ```\n @property relationshipNames\n @static\n @type Object\n @readOnly\n */\n relationshipNames: Ember.computed(function () {\n var names = {\n hasMany: [],\n belongsTo: []\n };\n this.eachComputedProperty(function (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 = get(Blog, 'relatedTypes');\n //=> [ User, Post ]\n ```\n @property relatedTypes\n @static\n @type Ember.Array\n @readOnly\n */\n relatedTypes: relatedTypesDescriptor,\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 = get(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 @static\n @type Map\n @readOnly\n */\n relationshipsByName: relationshipsByNameDescriptor,\n relationshipsObject: relationshipsObjectDescriptor,\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 = get(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 @static\n @type Map\n @readOnly\n */\n fields: Ember.computed(function () {\n var map = new Map();\n this.eachComputedProperty(function (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 }).readOnly(),\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 @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 eachRelationship: function eachRelationship(callback, binding) {\n Ember.get(this, 'relationshipsByName').forEach(function (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 @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 eachRelatedType: function eachRelatedType(callback, binding) {\n var relationshipTypes = Ember.get(this, 'relatedTypes');\n\n for (var i = 0; i < relationshipTypes.length; i++) {\n var type = relationshipTypes[i];\n callback.call(binding, type);\n }\n },\n determineRelationshipType: function determineRelationshipType(knownSide, store) {\n var knownKey = knownSide.key;\n var knownKind = knownSide.kind;\n var inverse = this.inverseFor(knownKey, store); // let key;\n\n var otherKind;\n\n if (!inverse) {\n return knownKind === 'belongsTo' ? 'oneToNone' : 'manyToNone';\n } // key = inverse.name;\n\n\n otherKind = inverse.kind;\n\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 Blog from 'app/models/blog'\n let attributes = get(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 @static\n @type {Map}\n @readOnly\n */\n attributes: Ember.computed(function () {\n var _this8 = this;\n\n var map = new Map();\n this.eachComputedProperty(function (name, meta) {\n if (meta.isAttribute) {\n ( !(name !== 'id') && Ember.assert(\"You may not set `id` as an attribute on your model. Please remove any lines that look like: `id: attr('')` from \" + _this8.toString(), name !== 'id'));\n meta.name = name;\n map.set(name, meta);\n }\n });\n return map;\n }).readOnly(),\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 = get(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 @static\n @type {Map}\n @readOnly\n */\n transformedAttributes: Ember.computed(function () {\n var map = new Map();\n this.eachAttribute(function (key, meta) {\n if (meta.type) {\n map.set(key, meta.type);\n }\n });\n return map;\n }).readOnly(),\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 @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 eachAttribute: function eachAttribute(callback, binding) {\n Ember.get(this, 'attributes').forEach(function (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 @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 eachTransformedAttribute: function eachTransformedAttribute(callback, binding) {\n Ember.get(this, 'transformedAttributes').forEach(function (type, name) {\n callback.call(binding, name, type);\n });\n },\n\n /**\n Returns the name of the model class.\n @method toString\n @static\n */\n toString: function toString() {\n return \"model:\" + Ember.get(this, 'modelName');\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 ### 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 @extends EmberObject\n @uses Ember.MutableArray, DeprecatedEvented\n */\n\n var manyArray = Ember.Object.extend(Ember.MutableArray, Private.DeprecatedEvented, {\n // here to make TS happy\n _inverseIsAsync: false,\n isLoaded: false,\n init: function init() {\n this._super.apply(this, arguments);\n /**\n The loading state of this array\n @property {Boolean} isLoaded\n */\n\n\n this.isLoaded = this.isLoaded || false; // async has-many rendering tests\n\n this._length = 0;\n /**\n Used for async `hasMany` arrays\n to keep track of when they will resolve.\n @property {Ember.RSVP.Promise} promise\n @private\n */\n\n this.promise = null;\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 metadata via the `meta` property:\n ```js\n post.get('comments').then(function(comments) {\n var meta = comments.get('meta');\n // meta.page => 1\n // meta.total => 5\n });\n ```\n @property {Object} meta\n @public\n */\n // TODO this is likely broken in our refactor\n\n this.meta = this.meta || null;\n /**\n `true` if the relationship is polymorphic, `false` otherwise.\n @property {Boolean} isPolymorphic\n @private\n */\n\n this.isPolymorphic = this.isPolymorphic || false;\n /**\n The relationship which manages this array.\n @property {ManyRelationship} relationship\n @private\n */\n\n this.currentState = [];\n this.flushCanonical(this.initialState, false); // we don't need this anymore, it just prevents garbage collection the records in the initialState\n\n this.initialState = undefined;\n },\n // TODO: if(DEBUG)\n anyUnloaded: function anyUnloaded() {\n // Use `filter[0]` as opposed to `find` because of IE11\n var unloaded = this.currentState.filter(function (im) {\n return im._isDematerializing || !im.isLoaded();\n })[0];\n return !!unloaded;\n },\n removeUnloadedInternalModel: function removeUnloadedInternalModel() {\n for (var i = 0; i < this.currentState.length; ++i) {\n var internalModel = this.currentState[i];\n var shouldRemove = void 0;\n\n {\n shouldRemove = internalModel._isDematerializing || !internalModel.isLoaded();\n }\n\n if (shouldRemove) {\n this.arrayContentWillChange(i, 1, 0);\n this.currentState.splice(i, 1);\n this.set('length', this.currentState.length);\n this.arrayContentDidChange(i, 1, 0);\n return true;\n }\n }\n\n return false;\n },\n\n get length() {\n // By using `get()`, the tracking system knows to pay attention to changes that occur.\n Ember.get(this, '[]');\n return this._length;\n },\n\n set length(value) {\n return this._length = value;\n },\n\n objectAt: function objectAt(index) {\n // TODO we likely need to force flush here\n\n /*\n if (this.relationship._willUpdateManyArray) {\n this.relationship._flushPendingManyArrayUpdates();\n }\n */\n var internalModel = this.currentState[index];\n\n if (internalModel === undefined) {\n return;\n }\n\n return internalModel.getRecord();\n },\n flushCanonical: function flushCanonical(toSet, isInitialized) {\n if (isInitialized === void 0) {\n isInitialized = true;\n }\n\n // It’s possible the parent side of the relationship may have been unloaded by this point\n if (!Private._objectIsAlive(this)) {\n return;\n } // diff to find changes\n\n\n var diff = Private.diffArray(this.currentState, toSet);\n\n if (diff.firstChangeIndex !== null) {\n // it's null if no change found\n // we found a change\n this.arrayContentWillChange(diff.firstChangeIndex, diff.removedCount, diff.addedCount);\n this.set('length', toSet.length);\n this.currentState = toSet.slice();\n this.arrayContentDidChange(diff.firstChangeIndex, diff.removedCount, diff.addedCount);\n\n if (isInitialized && diff.addedCount > 0) {\n //notify only on additions\n //TODO only notify if unloaded\n this.internalModel.manyArrayRecordAdded(this.get('key'));\n }\n }\n },\n replace: function replace(idx, amt, objects) {\n var internalModels;\n\n if (amt > 0) {\n internalModels = this.currentState.slice(idx, idx + amt);\n this.get('recordData').removeFromHasMany(this.get('key'), internalModels.map(function (im) {\n return Private.recordDataFor(im);\n }));\n }\n\n if (objects) {\n ( !(Array.isArray(objects) || Ember.Array.detect(objects)) && Ember.assert('The third argument to replace needs to be an array.', Array.isArray(objects) || Ember.Array.detect(objects)));\n this.get('recordData').addToHasMany(this.get('key'), objects.map(function (obj) {\n return Private.recordDataFor(obj);\n }), idx);\n }\n\n this.retrieveLatest();\n },\n // Ok this is kinda funky because if buggy we might lose positions, etc.\n // but current code is this way so shouldn't be too big of a problem\n retrieveLatest: function retrieveLatest() {\n var jsonApi = this.get('recordData').getHasMany(this.get('key')); // TODO this is odd, why should ManyArray ever tell itself to resync?\n\n var internalModels = this.store._getHasManyByJsonApiResource(jsonApi);\n\n if (jsonApi.meta) {\n this.set('meta', jsonApi.meta);\n }\n\n if (jsonApi.links) {\n this.set('links', jsonApi.links);\n }\n\n this.flushCanonical(internalModels, true);\n },\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 var user = store.peekRecord('user', 1)\n user.login().then(function() {\n user.get('permissions').then(function(permissions) {\n return permissions.reload();\n });\n });\n ```\n @method reload\n @public\n */\n reload: function reload(options) {\n // TODO this is odd, we don't ask the store for anything else like this?\n return this.get('store').reloadManyArray(this, this.get('internalModel'), this.get('key'), options);\n },\n\n /**\n Saves all of the records in the `ManyArray`.\n Example\n ```javascript\n store.findRecord('inbox', 1).then(function(inbox) {\n inbox.get('messages').then(function(messages) {\n messages.forEach(function(message) {\n message.set('isRead', true);\n });\n messages.save()\n });\n });\n ```\n @method save\n @return {PromiseArray} promise\n */\n save: function save() {\n var manyArray = this;\n var promiseLabel = 'DS: ManyArray#save ' + Ember.get(this, 'type');\n var promise = Ember.RSVP.all(this.invoke('save'), promiseLabel).then(function () {\n return manyArray;\n }, null, 'DS: ManyArray#save return ManyArray');\n return Private.PromiseArray.create({\n promise: promise\n });\n },\n\n /**\n Create a child record within the owner\n @method createRecord\n @private\n @param {Object} hash\n @return {Model} record\n */\n createRecord: function createRecord(hash) {\n var store = Ember.get(this, 'store');\n var type = Ember.get(this, 'type');\n ( !(!Ember.get(this, 'isPolymorphic')) && Ember.assert(\"You cannot add '\" + type.modelName + \"' records to this polymorphic relationship.\", !Ember.get(this, 'isPolymorphic')));\n var 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\n var 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: Ember.computed(function () {\n ( Ember.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: function reload(options) {\n var _this = this;\n\n ( !(this.get('content') !== undefined) && Ember.assert('You are trying to reload an async belongsTo before it has been created', this.get('content') !== undefined));\n var _this$_belongsToState = this._belongsToState,\n key = _this$_belongsToState.key,\n store = _this$_belongsToState.store,\n originatingInternalModel = _this$_belongsToState.originatingInternalModel;\n return store.reloadBelongsTo(this, originatingInternalModel, key, options).then(function () {\n return _this;\n });\n }\n });\n\n /**\n @module @ember-data/model\n */\n\n /**\n A PromiseManyArray is a PromiseArray that also proxies certain method calls\n to the underlying manyArray.\n Right now we proxy:\n\n * `reload()`\n * `createRecord()`\n * `on()`\n * `one()`\n * `trigger()`\n * `off()`\n * `has()`\n\n @class PromiseManyArray\n @extends Ember.ArrayProxy\n @private\n */\n\n var PromiseManyArray = Private.PromiseArray.extend({\n links: Ember.computed.reads('content.links'),\n reload: function reload(options) {\n ( !(Ember.get(this, 'content')) && Ember.assert('You are trying to reload an async manyArray before it has been created', Ember.get(this, 'content')));\n this.set('promise', this.get('content').reload(options));\n return this;\n },\n createRecord: proxyToContent('createRecord'),\n on: proxyToContent('on'),\n one: proxyToContent('one'),\n trigger: proxyToContent('trigger'),\n off: proxyToContent('off'),\n has: proxyToContent('has')\n });\n\n function proxyToContent(method) {\n return function () {\n var _Ember$get;\n\n return (_Ember$get = Ember.get(this, 'content'))[method].apply(_Ember$get, arguments);\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 metadata. 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 var owner = Ember.getOwner(store);\n var MaybeMixin = owner.factoryFor(\"mixin:\" + normalizedModelName);\n var mixin = MaybeMixin && MaybeMixin.class;\n\n if (mixin) {\n var ModelForMixin = Model.extend(mixin);\n ModelForMixin.reopenClass({\n __isMixin: true,\n __mixin: mixin\n }); //Cache the class as a model\n\n owner.register('model:' + normalizedModelName, ModelForMixin);\n }\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.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, \"default\", {\n enumerable: true,\n get: function get() {\n return _private.Model;\n }\n });\n Object.defineProperty(_exports, \"attr\", {\n enumerable: true,\n get: function get() {\n return _private.attr;\n }\n });\n Object.defineProperty(_exports, \"belongsTo\", {\n enumerable: true,\n get: function get() {\n return _private.belongsTo;\n }\n });\n Object.defineProperty(_exports, \"hasMany\", {\n enumerable: true,\n get: function get() {\n return _private.hasMany;\n }\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 = {\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 _exports.default = _default;\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 /**\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 abvoe `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 = {\n DEPRECATE_CATCH_ALL: '99.0',\n DEPRECATE_EVENTED_API_USAGE: '3.12',\n DEPRECATE_RECORD_LIFECYCLE_EVENT_METHODS: '3.12',\n DEPRECATE_MODEL_TOJSON: '3.15',\n DEPRECATE_LEGACY_TEST_HELPER_SUPPORT: '3.15',\n DEPRECATE_LEGACY_TEST_REGISTRATIONS: '3.15',\n DEPRECATE_DEFAULT_SERIALIZER: '3.15',\n DEPRECATE_DEFAULT_ADAPTER: '3.15',\n DEPRECATE_METHOD_CALLS_ON_DESTROY_STORE: '3.15',\n DEPRECATE_MISMATCHED_INVERSE_RELATIONSHIP_DATA: '3.12',\n DEPRECATE_BELONGS_TO_REFERENCE_PUSH: '3.16',\n DEPRECATE_REFERENCE_INTERNAL_MODEL: '3.19',\n DEPRECATE_NAJAX: '3.22'\n };\n _exports.default = _default;\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_NAJAX = _exports.DEPRECATE_REFERENCE_INTERNAL_MODEL = _exports.DEPRECATE_BELONGS_TO_REFERENCE_PUSH = _exports.DEPRECATE_MISMATCHED_INVERSE_RELATIONSHIP_DATA = _exports.DEPRECATE_METHOD_CALLS_ON_DESTROY_STORE = _exports.DEPRECATE_DEFAULT_ADAPTER = _exports.DEPRECATE_DEFAULT_SERIALIZER = _exports.DEPRECATE_LEGACY_TEST_REGISTRATIONS = _exports.DEPRECATE_LEGACY_TEST_HELPER_SUPPORT = _exports.DEPRECATE_MODEL_TOJSON = _exports.DEPRECATE_RECORD_LIFECYCLE_EVENT_METHODS = _exports.DEPRECATE_EVENTED_API_USAGE = _exports.DEPRECATE_CATCH_ALL = void 0;\n\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 } // deprecations\n\n\n var DEPRECATE_CATCH_ALL = deprecationState('DEPRECATE_CATCH_ALL');\n _exports.DEPRECATE_CATCH_ALL = DEPRECATE_CATCH_ALL;\n var DEPRECATE_EVENTED_API_USAGE = deprecationState('DEPRECATE_EVENTED_API_USAGE');\n _exports.DEPRECATE_EVENTED_API_USAGE = DEPRECATE_EVENTED_API_USAGE;\n var DEPRECATE_RECORD_LIFECYCLE_EVENT_METHODS = deprecationState('DEPRECATE_RECORD_LIFECYCLE_EVENT_METHODS');\n _exports.DEPRECATE_RECORD_LIFECYCLE_EVENT_METHODS = DEPRECATE_RECORD_LIFECYCLE_EVENT_METHODS;\n var DEPRECATE_MODEL_TOJSON = deprecationState('DEPRECATE_MODEL_TOJSON');\n _exports.DEPRECATE_MODEL_TOJSON = DEPRECATE_MODEL_TOJSON;\n var DEPRECATE_LEGACY_TEST_HELPER_SUPPORT = deprecationState('DEPRECATE_LEGACY_TEST_HELPER_SUPPORT');\n _exports.DEPRECATE_LEGACY_TEST_HELPER_SUPPORT = DEPRECATE_LEGACY_TEST_HELPER_SUPPORT;\n var DEPRECATE_LEGACY_TEST_REGISTRATIONS = deprecationState('DEPRECATE_LEGACY_TEST_REGISTRATIONS');\n _exports.DEPRECATE_LEGACY_TEST_REGISTRATIONS = DEPRECATE_LEGACY_TEST_REGISTRATIONS;\n var DEPRECATE_DEFAULT_SERIALIZER = deprecationState('DEPRECATE_DEFAULT_SERIALIZER');\n _exports.DEPRECATE_DEFAULT_SERIALIZER = DEPRECATE_DEFAULT_SERIALIZER;\n var DEPRECATE_DEFAULT_ADAPTER = deprecationState('DEPRECATE_DEFAULT_ADAPTER');\n _exports.DEPRECATE_DEFAULT_ADAPTER = DEPRECATE_DEFAULT_ADAPTER;\n var DEPRECATE_METHOD_CALLS_ON_DESTROY_STORE = deprecationState('DEPRECATE_METHOD_CALLS_ON_DESTROY_STORE');\n _exports.DEPRECATE_METHOD_CALLS_ON_DESTROY_STORE = DEPRECATE_METHOD_CALLS_ON_DESTROY_STORE;\n var DEPRECATE_MISMATCHED_INVERSE_RELATIONSHIP_DATA = deprecationState('DEPRECATE_MISMATCHED_INVERSE_RELATIONSHIP_DATA');\n _exports.DEPRECATE_MISMATCHED_INVERSE_RELATIONSHIP_DATA = DEPRECATE_MISMATCHED_INVERSE_RELATIONSHIP_DATA;\n var DEPRECATE_BELONGS_TO_REFERENCE_PUSH = deprecationState('DEPRECATE_BELONGS_TO_REFERENCE_PUSH');\n _exports.DEPRECATE_BELONGS_TO_REFERENCE_PUSH = DEPRECATE_BELONGS_TO_REFERENCE_PUSH;\n var DEPRECATE_REFERENCE_INTERNAL_MODEL = deprecationState('DEPRECATE_REFERENCE_INTERNAL_MODEL');\n _exports.DEPRECATE_REFERENCE_INTERNAL_MODEL = DEPRECATE_REFERENCE_INTERNAL_MODEL;\n var DEPRECATE_NAJAX = deprecationState('DEPRECATE_NAJAX');\n _exports.DEPRECATE_NAJAX = DEPRECATE_NAJAX;\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_RECORD_DATA_PACKAGE = _exports.HAS_DEBUG_PACKAGE = _exports.HAS_SERIALIZER_PACKAGE = _exports.HAS_ADAPTER_PACKAGE = _exports.HAS_MODEL_PACKAGE = _exports.HAS_STORE_PACKAGE = _exports.HAS_EMBER_DATA_PACKAGE = void 0;\n\n function flagState(flag) {\n var packageName = _availablePackages.default[flag];\n return (0, _require.has)(packageName) || false;\n }\n\n var HAS_EMBER_DATA_PACKAGE = flagState('HAS_EMBER_DATA_PACKAGE');\n _exports.HAS_EMBER_DATA_PACKAGE = HAS_EMBER_DATA_PACKAGE;\n var HAS_STORE_PACKAGE = flagState('HAS_STORE_PACKAGE');\n _exports.HAS_STORE_PACKAGE = HAS_STORE_PACKAGE;\n var HAS_MODEL_PACKAGE = flagState('HAS_MODEL_PACKAGE');\n _exports.HAS_MODEL_PACKAGE = HAS_MODEL_PACKAGE;\n var HAS_ADAPTER_PACKAGE = flagState('HAS_ADAPTER_PACKAGE');\n _exports.HAS_ADAPTER_PACKAGE = HAS_ADAPTER_PACKAGE;\n var HAS_SERIALIZER_PACKAGE = flagState('HAS_SERIALIZER_PACKAGE');\n _exports.HAS_SERIALIZER_PACKAGE = HAS_SERIALIZER_PACKAGE;\n var HAS_DEBUG_PACKAGE = flagState('HAS_DEBUG_PACKAGE');\n _exports.HAS_DEBUG_PACKAGE = HAS_DEBUG_PACKAGE;\n var HAS_RECORD_DATA_PACKAGE = flagState('HAS_RECORD_DATA_PACKAGE');\n _exports.HAS_RECORD_DATA_PACKAGE = HAS_RECORD_DATA_PACKAGE;\n});","define('@ember-data/record-data/-private', ['exports', '@ember-data/store/-private', '@ember-data/store/-debug', '@ember/ordered-set'], function (exports, Private, Debug, EmberOrderedSet) { 'use strict';\n\n EmberOrderedSet = EmberOrderedSet && Object.prototype.hasOwnProperty.call(EmberOrderedSet, 'default') ? EmberOrderedSet['default'] : EmberOrderedSet;\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 function coerceId(id) {\n if (id === null || id === undefined || id === '') {\n return null;\n }\n\n if (typeof id === 'string') {\n return id;\n }\n\n if (typeof id === 'symbol') {\n return id.toString();\n }\n\n return '' + id;\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 @method _normalizeLink\n @internal\n @param {String} link\n @return {Object|null}\n */\n function _normalizeLink(link) {\n switch (typeof link) {\n case 'object':\n return link;\n\n case 'string':\n return {\n href: link\n };\n }\n\n return null;\n }\n\n function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }\n\n function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }\n\n var EmberDataOrderedSet = /*#__PURE__*/function (_EmberOrderedSet) {\n _inheritsLoose(EmberDataOrderedSet, _EmberOrderedSet);\n\n function EmberDataOrderedSet() {\n return _EmberOrderedSet.apply(this, arguments) || this;\n }\n\n EmberDataOrderedSet.create = function create() {\n return new this();\n };\n\n var _proto = EmberDataOrderedSet.prototype;\n\n _proto.addWithIndex = function addWithIndex(obj, idx) {\n var guid = Ember.guidFor(obj);\n var presenceSet = this.presenceSet;\n var list = this.list;\n\n if (presenceSet[guid] === true) {\n return;\n }\n\n presenceSet[guid] = true;\n\n if (idx === undefined || idx === null) {\n list.push(obj);\n } else {\n list.splice(idx, 0, obj);\n }\n\n this.size += 1;\n return this;\n };\n\n _proto.deleteWithIndex = function deleteWithIndex(obj, idx) {\n var guid = Ember.guidFor(obj);\n var presenceSet = this.presenceSet;\n var list = this.list;\n\n if (presenceSet[guid] === true) {\n delete presenceSet[guid];\n ( !(idx === undefined || list[idx] === obj) && Ember.assert('object is not present at specified index', idx === undefined || list[idx] === obj));\n var index = idx !== undefined ? idx : list.indexOf(obj);\n\n if (index > -1) {\n list.splice(index, 1);\n }\n\n this.size = list.length;\n return true;\n } else {\n return false;\n }\n };\n\n return EmberDataOrderedSet;\n }(EmberOrderedSet);\n\n function relationshipsFor(instance) {\n var recordData = Private.recordDataFor(instance) || instance;\n return recordData._relationships;\n }\n function relationshipStateFor(instance, propertyName) {\n return relationshipsFor(instance).get(propertyName);\n }\n function implicitRelationshipsFor(instance) {\n var recordData = Private.recordDataFor(instance) || instance;\n return recordData._implicitRelationships;\n }\n function implicitRelationshipStateFor(instance, propertyName) {\n return implicitRelationshipsFor(instance)[propertyName];\n }\n\n function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\n function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }\n\n var Relationship = /*#__PURE__*/function () {\n function Relationship(store, inverseKey, relationshipMeta, recordData, inverseIsAsync) {\n this.inverseIsAsync = void 0;\n this.kind = void 0;\n this.recordData = void 0;\n this.members = void 0;\n this.canonicalMembers = void 0;\n this.store = void 0;\n this.key = void 0;\n this.inverseKey = void 0;\n this.isAsync = void 0;\n this.isPolymorphic = void 0;\n this.relationshipMeta = void 0;\n this.inverseKeyForImplicit = void 0;\n this.meta = void 0;\n this.__inverseMeta = void 0;\n this._tempModelName = void 0;\n this.shouldForceReload = false;\n this.relationshipIsStale = void 0;\n this.hasDematerializedInverse = void 0;\n this.hasAnyRelationshipData = void 0;\n this.relationshipIsEmpty = void 0;\n this.hasFailedLoadAttempt = false;\n this.links = void 0;\n this.willSync = void 0;\n this.inverseIsAsync = inverseIsAsync;\n this.kind = relationshipMeta.kind;\n var async = relationshipMeta.options.async;\n var polymorphic = relationshipMeta.options.polymorphic;\n this.recordData = recordData;\n this.members = new EmberDataOrderedSet();\n this.canonicalMembers = new EmberDataOrderedSet();\n this.store = store;\n this.key = relationshipMeta.key || null;\n this.inverseKey = inverseKey;\n this.isAsync = typeof async === 'undefined' ? true : async;\n this.isPolymorphic = typeof polymorphic === 'undefined' ? false : polymorphic;\n this.relationshipMeta = relationshipMeta; //This probably breaks for polymorphic relationship in complex scenarios, due to\n //multiple possible modelNames\n\n this.inverseKeyForImplicit = this._tempModelName + this.key;\n this.meta = null;\n this.__inverseMeta = undefined;\n /*\n This flag forces fetch. `true` for a single request once `reload()`\n has been called `false` at all other times.\n */\n // this.shouldForceReload = false;\n\n /*\n This flag indicates whether we should\n re-fetch the relationship the next time\n it is accessed.\n The difference between this flag and `shouldForceReload`\n is in how we treat the presence of partially missing data:\n - for a forced reload, we will reload the link or EVERY record\n - for a stale reload, we will reload the link (if present) else only MISSING records\n Ideally these flags could be merged, but because we don't give the\n request layer the option of deciding how to resolve the data being queried\n we are forced to differentiate for now.\n It is also possible for a relationship to remain stale after a forced reload; however,\n in this case `hasFailedLoadAttempt` ought to be `true`.\n false when\n => recordData.isNew() on initial setup\n => a previously triggered request has resolved\n => we get relationship data via push\n true when\n => !recordData.isNew() on initial setup\n => an inverse has been unloaded\n => we get a new link for the relationship\n TODO @runspired unskip the acceptance tests and fix these flags\n */\n\n this.relationshipIsStale = false;\n /*\n This flag indicates whether we should\n **partially** re-fetch the relationship the\n next time it is accessed.\n false when\n => initial setup\n => a previously triggered request has resolved\n true when\n => an inverse has been unloaded\n */\n\n this.hasDematerializedInverse = false;\n /*\n This flag indicates whether we should consider the content\n of this relationship \"known\".\n If we have no relationship knowledge, and the relationship\n is `async`, we will attempt to fetch the relationship on\n access if it is also stale.\n Snapshot uses this to tell the difference between unknown\n (`undefined`) or empty (`null`). The reason for this is that\n we wouldn't want to serialize unknown relationships as `null`\n as that might overwrite remote state.\n All relationships for a newly created (`store.createRecord()`) are\n considered known (`hasAnyRelationshipData === true`).\n true when\n => we receive a push with either new data or explicit empty (`[]` or `null`)\n => the relationship is a belongsTo and we have received data from\n the other side.\n false when\n => we have received no signal about what data belongs in this relationship\n => the relationship is a hasMany and we have only received data from\n the other side.\n */\n\n this.hasAnyRelationshipData = false;\n /*\n Flag that indicates whether an empty relationship is explicitly empty\n (signaled by push giving us an empty array or null relationship)\n e.g. an API response has told us that this relationship is empty.\n Thus far, it does not appear that we actually need this flag; however,\n @runspired has found it invaluable when debugging relationship tests\n to determine whether (and why if so) we are in an incorrect state.\n true when\n => we receive a push with explicit empty (`[]` or `null`)\n => we have received no signal about what data belongs in this relationship\n => on initial create (as no signal is known yet)\n false at all other times\n */\n\n this.relationshipIsEmpty = true;\n /*\n Flag def here for reference, defined as getter in has-many.js / belongs-to.js\n true when\n => hasAnyRelationshipData is true\n AND\n => members (NOT canonicalMembers) @each !isEmpty\n TODO, consider changing the conditional here from !isEmpty to !hiddenFromRecordArrays\n */\n // TODO do we want this anymore? Seems somewhat useful\n // especially if we rename to `hasUpdatedLink`\n // which would tell us slightly more about why the\n // relationship is stale\n // this.updatedLink = false;\n }\n\n var _proto = Relationship.prototype;\n\n _proto._inverseIsAsync = function _inverseIsAsync() {\n return !!this.inverseIsAsync;\n };\n\n _proto._inverseIsSync = function _inverseIsSync() {\n return !!(this.inverseKey && !this.inverseIsAsync);\n };\n\n _proto._hasSupportForImplicitRelationships = function _hasSupportForImplicitRelationships(recordData) {\n return recordData._implicitRelationships !== undefined && recordData._implicitRelationships !== null;\n };\n\n _proto._hasSupportForRelationships = function _hasSupportForRelationships(recordData) {\n return recordData._relationships !== undefined && recordData._relationships !== null;\n };\n\n _proto.recordDataDidDematerialize = function recordDataDidDematerialize() {\n var _this = this;\n\n var inverseKey = this.inverseKey;\n\n if (!inverseKey) {\n return;\n } // we actually want a union of members and canonicalMembers\n // they should be disjoint but currently are not due to a bug\n\n\n this.forAllMembers(function (inverseRecordData) {\n if (!_this._hasSupportForRelationships(inverseRecordData)) {\n return;\n }\n\n var relationship = relationshipStateFor(inverseRecordData, inverseKey);\n\n var belongsToRelationship = inverseRecordData.getBelongsTo(inverseKey)._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\n\n if (!belongsToRelationship || !belongsToRelationship.inverseRecordData || _this.recordData === belongsToRelationship.inverseRecordData) {\n relationship.inverseDidDematerialize(_this.recordData);\n }\n });\n };\n\n _proto.forAllMembers = function forAllMembers(callback) {\n var seen = Object.create(null);\n\n for (var i = 0; i < this.members.list.length; i++) {\n var inverseInternalModel = this.members.list[i];\n var id = Ember.guidFor(inverseInternalModel);\n\n if (!seen[id]) {\n seen[id] = true;\n callback(inverseInternalModel);\n }\n }\n\n for (var _i = 0; _i < this.canonicalMembers.list.length; _i++) {\n var _inverseInternalModel = this.canonicalMembers.list[_i];\n\n var _id = Ember.guidFor(_inverseInternalModel);\n\n if (!seen[_id]) {\n seen[_id] = true;\n callback(_inverseInternalModel);\n }\n }\n };\n\n _proto.inverseDidDematerialize = function inverseDidDematerialize(inverseRecordData) {\n if (!this.isAsync || inverseRecordData && inverseRecordData.isNew()) {\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.removeRecordDataFromOwn(inverseRecordData);\n this.removeCanonicalRecordDataFromOwn(inverseRecordData);\n this.setRelationshipIsEmpty(true);\n } else {\n this.setHasDematerializedInverse(true);\n }\n };\n\n _proto.updateMeta = function updateMeta(meta) {\n this.meta = meta;\n };\n\n _proto.clear = function clear() {\n var members = this.members.list;\n\n while (members.length > 0) {\n var member = members[0];\n this.removeRecordData(member);\n }\n\n var canonicalMembers = this.canonicalMembers.list;\n\n while (canonicalMembers.length > 0) {\n var _member = canonicalMembers[0];\n this.removeCanonicalRecordData(_member);\n }\n };\n\n _proto.removeAllRecordDatasFromOwn = function removeAllRecordDatasFromOwn() {\n this.setRelationshipIsStale(true);\n this.members.clear();\n };\n\n _proto.removeAllCanonicalRecordDatasFromOwn = function removeAllCanonicalRecordDatasFromOwn() {\n this.canonicalMembers.clear();\n this.flushCanonicalLater();\n };\n\n _proto.removeRecordDatas = function removeRecordDatas(recordDatas) {\n var _this2 = this;\n\n recordDatas.forEach(function (recordData) {\n return _this2.removeRecordData(recordData);\n });\n };\n\n _proto.addRecordDatas = function addRecordDatas(recordDatas, idx) {\n var _this3 = this;\n\n recordDatas.forEach(function (recordData) {\n _this3.addRecordData(recordData, idx);\n\n if (idx !== undefined) {\n idx++;\n }\n });\n };\n\n _proto.addCanonicalRecordData = function addCanonicalRecordData(recordData, idx) {\n if (!this.canonicalMembers.has(recordData)) {\n this.canonicalMembers.add(recordData);\n this.setupInverseRelationship(recordData);\n }\n\n this.flushCanonicalLater();\n this.setHasAnyRelationshipData(true);\n };\n\n _proto.setupInverseRelationship = function setupInverseRelationship(recordData) {\n if (this.inverseKey) {\n if (!this._hasSupportForRelationships(recordData)) {\n return;\n }\n\n var relationship = relationshipStateFor(recordData, this.inverseKey); // if we have only just initialized the inverse relationship, then it\n // already has this.recordData in its canonicalMembers, so skip the\n // unnecessary work. The exception to this is polymorphic\n // relationships whose members are determined by their inverse, as those\n // relationships cannot efficiently find their inverse payloads.\n\n relationship.addCanonicalRecordData(this.recordData);\n } else {\n if (!this._hasSupportForImplicitRelationships(recordData)) {\n return;\n }\n\n var relationships = recordData._implicitRelationships;\n var _relationship = relationships[this.inverseKeyForImplicit];\n\n if (!_relationship) {\n _relationship = relationships[this.inverseKeyForImplicit] = new Relationship(this.store, this.key, {\n options: {\n async: this.isAsync\n }\n }, recordData);\n }\n\n _relationship.addCanonicalRecordData(this.recordData);\n }\n };\n\n _proto.removeCanonicalRecordDatas = function removeCanonicalRecordDatas(recordDatas, idx) {\n for (var i = 0; i < recordDatas.length; i++) {\n if (idx !== undefined) {\n this.removeCanonicalRecordData(recordDatas[i], i + idx);\n } else {\n this.removeCanonicalRecordData(recordDatas[i]);\n }\n }\n };\n\n _proto.removeCanonicalRecordData = function removeCanonicalRecordData(recordData, idx) {\n if (this.canonicalMembers.has(recordData)) {\n this.removeCanonicalRecordDataFromOwn(recordData, idx);\n\n if (this.inverseKey) {\n this.removeCanonicalRecordDataFromInverse(recordData);\n } else {\n if (this._hasSupportForImplicitRelationships(recordData) && recordData._implicitRelationships[this.inverseKeyForImplicit]) {\n recordData._implicitRelationships[this.inverseKeyForImplicit].removeCanonicalRecordData(this.recordData);\n }\n }\n }\n\n this.flushCanonicalLater();\n };\n\n _proto.addRecordData = function addRecordData(recordData, idx) {\n if (!this.members.has(recordData)) {\n this.members.addWithIndex(recordData, idx);\n this.notifyRecordRelationshipAdded(recordData, idx);\n\n if (this._hasSupportForRelationships(recordData) && this.inverseKey) {\n relationshipStateFor(recordData, this.inverseKey).addRecordData(this.recordData);\n } else {\n if (this._hasSupportForImplicitRelationships(recordData)) {\n if (!recordData._implicitRelationships[this.inverseKeyForImplicit]) {\n recordData._implicitRelationships[this.inverseKeyForImplicit] = new Relationship(this.store, this.key, {\n options: {\n async: this.isAsync\n }\n }, recordData, this.isAsync);\n }\n\n recordData._implicitRelationships[this.inverseKeyForImplicit].addRecordData(this.recordData);\n }\n }\n }\n\n this.setHasAnyRelationshipData(true);\n };\n\n _proto.removeRecordData = function removeRecordData(recordData) {\n if (this.members.has(recordData)) {\n this.removeRecordDataFromOwn(recordData);\n\n if (this.inverseKey) {\n this.removeRecordDataFromInverse(recordData);\n } else {\n if (this._hasSupportForImplicitRelationships(recordData) && recordData._implicitRelationships[this.inverseKeyForImplicit]) {\n recordData._implicitRelationships[this.inverseKeyForImplicit].removeRecordData(this.recordData);\n }\n }\n }\n };\n\n _proto.removeRecordDataFromInverse = function removeRecordDataFromInverse(recordData) {\n if (!this._hasSupportForRelationships(recordData)) {\n return;\n }\n\n if (this.inverseKey) {\n var inverseRelationship = relationshipStateFor(recordData, this.inverseKey); //Need to check for existence, as the record might unloading at the moment\n\n if (inverseRelationship) {\n inverseRelationship.removeRecordDataFromOwn(this.recordData);\n }\n }\n };\n\n _proto.removeRecordDataFromOwn = function removeRecordDataFromOwn(recordData, idx) {\n this.members.delete(recordData);\n };\n\n _proto.removeCanonicalRecordDataFromInverse = function removeCanonicalRecordDataFromInverse(recordData) {\n if (!this._hasSupportForRelationships(recordData)) {\n return;\n }\n\n if (this.inverseKey) {\n var inverseRelationship = relationshipStateFor(recordData, this.inverseKey); //Need to check for existence, as the record might unloading at the moment\n\n if (inverseRelationship) {\n inverseRelationship.removeCanonicalRecordDataFromOwn(this.recordData);\n }\n }\n };\n\n _proto.removeCanonicalRecordDataFromOwn = function removeCanonicalRecordDataFromOwn(recordData, idx) {\n this.canonicalMembers.deleteWithIndex(recordData, idx);\n this.flushCanonicalLater();\n }\n /*\n Call this method once a record deletion has been persisted\n to purge it from BOTH current and canonical state of all\n relationships.\n @method removeCompletelyFromInverse\n @private\n */\n ;\n\n _proto.removeCompletelyFromInverse = function removeCompletelyFromInverse() {\n var _this4 = this;\n\n if (!this.inverseKey && !this.inverseKeyForImplicit) {\n return;\n } // we actually want a union of members and canonicalMembers\n // they should be disjoint but currently are not due to a bug\n\n\n var seen = Object.create(null);\n var recordData = this.recordData;\n var unload;\n\n if (this.inverseKey) {\n unload = function unload(inverseRecordData) {\n var id = Ember.guidFor(inverseRecordData);\n\n if (_this4._hasSupportForRelationships(inverseRecordData) && seen[id] === undefined) {\n if (_this4.inverseKey) {\n var relationship = relationshipStateFor(inverseRecordData, _this4.inverseKey);\n relationship.removeCompletelyFromOwn(recordData);\n }\n\n seen[id] = true;\n }\n };\n } else {\n unload = function unload(inverseRecordData) {\n var id = Ember.guidFor(inverseRecordData);\n\n if (_this4._hasSupportForImplicitRelationships(inverseRecordData) && seen[id] === undefined) {\n var relationship = implicitRelationshipStateFor(inverseRecordData, _this4.inverseKeyForImplicit);\n relationship.removeCompletelyFromOwn(recordData);\n seen[id] = true;\n }\n };\n }\n\n this.members.forEach(unload);\n this.canonicalMembers.forEach(unload);\n\n if (!this.isAsync) {\n this.clear();\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 ;\n\n _proto.removeCompletelyFromOwn = function removeCompletelyFromOwn(recordData) {\n this.canonicalMembers.delete(recordData);\n this.members.delete(recordData);\n };\n\n _proto.flushCanonical = function flushCanonical() {\n var list = this.members.list;\n this.willSync = false; //a hack for not removing new RecordDatas\n //TODO remove once we have proper diffing\n\n var newRecordDatas = [];\n\n for (var i = 0; i < list.length; i++) {\n // TODO Igor deal with this\n if (list[i].isNew()) {\n newRecordDatas.push(list[i]);\n }\n } //TODO(Igor) make this less abysmally slow\n\n\n this.members = this.canonicalMembers.copy();\n\n for (var _i2 = 0; _i2 < newRecordDatas.length; _i2++) {\n this.members.add(newRecordDatas[_i2]);\n }\n };\n\n _proto.flushCanonicalLater = function flushCanonicalLater() {\n if (this.willSync) {\n return;\n }\n\n this.willSync = true; // Reaching back into the store to use ED's runloop\n\n this.store._updateRelationshipState(this);\n };\n\n _proto.updateLinks = function updateLinks(links) {\n this.links = links;\n };\n\n _proto.updateRecordDatasFromAdapter = function updateRecordDatasFromAdapter(recordDatas) {\n this.setHasAnyRelationshipData(true); //TODO(Igor) move this to a proper place\n //TODO Once we have adapter support, we need to handle updated and canonical changes\n\n this.computeChanges(recordDatas);\n };\n\n _proto.computeChanges = function computeChanges(recordDatas) {};\n\n _proto.notifyRecordRelationshipAdded = function notifyRecordRelationshipAdded(recordData, idxs) {};\n\n _proto.setHasAnyRelationshipData = function setHasAnyRelationshipData(value) {\n this.hasAnyRelationshipData = value;\n };\n\n _proto.setHasDematerializedInverse = function setHasDematerializedInverse(value) {\n this.hasDematerializedInverse = value;\n };\n\n _proto.setRelationshipIsStale = function setRelationshipIsStale(value) {\n this.relationshipIsStale = value;\n };\n\n _proto.setRelationshipIsEmpty = function setRelationshipIsEmpty(value) {\n this.relationshipIsEmpty = value;\n };\n\n _proto.setShouldForceReload = function setShouldForceReload(value) {\n this.shouldForceReload = value;\n };\n\n _proto.setHasFailedLoadAttempt = function setHasFailedLoadAttempt(value) {\n this.hasFailedLoadAttempt = value;\n }\n /*\n `push` for a relationship allows the store to push a JSON API Relationship\n Object onto the relationship. The relationship will then extract and set the\n meta, data and links of that relationship.\n `push` use `updateMeta`, `updateData` and `updateLink` to update the state\n of the relationship.\n */\n ;\n\n _proto.push = function push(payload) {\n var hasRelationshipDataProperty = false;\n var hasLink = false;\n\n if (payload.meta) {\n this.updateMeta(payload.meta);\n }\n\n if (payload.data !== undefined) {\n hasRelationshipDataProperty = true;\n this.updateData(payload.data);\n } else if (this.isAsync === false && !this.hasAnyRelationshipData) {\n hasRelationshipDataProperty = true;\n var data = this.kind === 'hasMany' ? [] : null;\n this.updateData(data);\n }\n\n if (payload.links) {\n var originalLinks = this.links;\n this.updateLinks(payload.links);\n\n if (payload.links.related) {\n var relatedLink = _normalizeLink(payload.links.related);\n\n var currentLink = originalLinks && originalLinks.related ? _normalizeLink(originalLinks.related) : null;\n var currentLinkHref = currentLink ? currentLink.href : null;\n\n if (relatedLink && relatedLink.href && relatedLink.href !== currentLinkHref) {\n ( Ember.warn(\"You pushed a record of type '\" + this.recordData.modelName + \"' with a relationship '\" + this.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.\", this.isAsync || this.hasAnyRelationshipData, {\n id: 'ds.store.push-link-for-sync-relationship'\n }));\n ( !(typeof relatedLink.href === 'string' || relatedLink.href === null) && Ember.assert(\"You have pushed a record of type '\" + this.recordData.modelName + \"' with '\" + this.key + \"' as a link, but the value of that link is not a string.\", typeof relatedLink.href === 'string' || relatedLink.href === null));\n hasLink = true;\n }\n }\n }\n /*\n Data being pushed into the relationship might contain only data or links,\n or a combination of both.\n IF contains only data\n IF contains both links and data\n relationshipIsEmpty -> true if is empty array (has-many) or is null (belongs-to)\n hasAnyRelationshipData -> true\n hasDematerializedInverse -> false\n relationshipIsStale -> false\n allInverseRecordsAreLoaded -> run-check-to-determine\n IF contains only links\n relationshipIsStale -> true\n */\n\n\n this.setHasFailedLoadAttempt(false);\n\n if (hasRelationshipDataProperty) {\n var relationshipIsEmpty = payload.data === null || Array.isArray(payload.data) && payload.data.length === 0;\n this.setHasAnyRelationshipData(true);\n this.setRelationshipIsStale(false);\n this.setHasDematerializedInverse(false);\n this.setRelationshipIsEmpty(relationshipIsEmpty);\n } else if (hasLink) {\n this.setRelationshipIsStale(true);\n var recordData = this.recordData;\n var storeWrapper = this.recordData.storeWrapper;\n\n {\n storeWrapper.notifyPropertyChange(recordData.modelName, recordData.id, recordData.clientId, // We know we are not an implicit relationship here\n this.key);\n }\n }\n };\n\n _proto.localStateIsEmpty = function localStateIsEmpty() {};\n\n _proto.updateData = function updateData(payload) {};\n\n _proto.destroy = function destroy() {};\n\n _createClass(Relationship, [{\n key: \"isNew\",\n get: function get() {\n return this.recordData.isNew();\n }\n }, {\n key: \"_inverseMeta\",\n get: function get() {\n if (this.__inverseMeta === undefined) {\n var inverseMeta = null;\n\n if (this.inverseKey) {\n // We know we have a full inverse relationship\n var type = this.relationshipMeta.type;\n var inverseModelClass = this.store.modelFor(type);\n var inverseRelationships = Ember.get(inverseModelClass, 'relationshipsByName');\n inverseMeta = inverseRelationships.get(this.inverseKey);\n }\n\n this.__inverseMeta = inverseMeta;\n }\n\n return this.__inverseMeta;\n }\n }]);\n\n return Relationship;\n }();\n\n function _inheritsLoose$1(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf$1(subClass, superClass); }\n\n function _setPrototypeOf$1(o, p) { _setPrototypeOf$1 = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$1(o, p); }\n\n var BelongsToRelationship = /*#__PURE__*/function (_Relationship) {\n _inheritsLoose$1(BelongsToRelationship, _Relationship);\n\n function BelongsToRelationship(store, inverseKey, relationshipMeta, recordData, inverseIsAsync) {\n var _this;\n\n _this = _Relationship.call(this, store, inverseKey, relationshipMeta, recordData, inverseIsAsync) || this;\n _this.inverseRecordData = void 0;\n _this.canonicalState = void 0;\n _this.key = void 0;\n _this.key = relationshipMeta.key;\n _this.inverseRecordData = null;\n _this.canonicalState = null;\n _this.key = relationshipMeta.key;\n return _this;\n }\n\n var _proto = BelongsToRelationship.prototype;\n\n _proto.setRecordData = function setRecordData(recordData) {\n if (recordData) {\n this.addRecordData(recordData);\n } else if (this.inverseRecordData) {\n this.removeRecordData(this.inverseRecordData);\n }\n\n this.setHasAnyRelationshipData(true);\n this.setRelationshipIsStale(false);\n this.setRelationshipIsEmpty(false);\n };\n\n _proto.setCanonicalRecordData = function setCanonicalRecordData(recordData) {\n if (recordData) {\n this.addCanonicalRecordData(recordData);\n } else if (this.canonicalState) {\n this.removeCanonicalRecordData(this.canonicalState);\n }\n\n this.flushCanonicalLater();\n };\n\n _proto.addCanonicalRecordData = function addCanonicalRecordData(recordData) {\n if (this.canonicalMembers.has(recordData)) {\n return;\n }\n\n if (this.canonicalState) {\n this.removeCanonicalRecordData(this.canonicalState);\n }\n\n this.canonicalState = recordData;\n\n _Relationship.prototype.addCanonicalRecordData.call(this, recordData);\n\n this.setHasAnyRelationshipData(true);\n this.setRelationshipIsEmpty(false);\n };\n\n _proto.inverseDidDematerialize = function inverseDidDematerialize() {\n _Relationship.prototype.inverseDidDematerialize.call(this, this.inverseRecordData);\n\n this.notifyBelongsToChange();\n };\n\n _proto.removeCompletelyFromOwn = function removeCompletelyFromOwn(recordData) {\n _Relationship.prototype.removeCompletelyFromOwn.call(this, recordData);\n\n if (this.canonicalState === recordData) {\n this.canonicalState = null;\n }\n\n if (this.inverseRecordData === recordData) {\n this.inverseRecordData = null;\n this.notifyBelongsToChange();\n }\n };\n\n _proto.removeCompletelyFromInverse = function removeCompletelyFromInverse() {\n _Relationship.prototype.removeCompletelyFromInverse.call(this);\n\n this.inverseRecordData = null;\n };\n\n _proto.flushCanonical = function flushCanonical() {\n //temporary fix to not remove newly created records if server returned null.\n //TODO remove once we have proper diffing\n if (this.inverseRecordData && this.inverseRecordData.isNew() && !this.canonicalState) {\n this.willSync = false;\n return;\n }\n\n if (this.inverseRecordData !== this.canonicalState) {\n this.inverseRecordData = this.canonicalState;\n this.notifyBelongsToChange();\n }\n\n _Relationship.prototype.flushCanonical.call(this);\n };\n\n _proto.addRecordData = function addRecordData(recordData) {\n if (this.members.has(recordData)) {\n return;\n } // TODO Igor cleanup\n\n\n Debug.assertPolymorphicType(this.recordData, this.relationshipMeta, recordData, this.store);\n\n if (this.inverseRecordData) {\n this.removeRecordData(this.inverseRecordData);\n }\n\n this.inverseRecordData = recordData;\n\n _Relationship.prototype.addRecordData.call(this, recordData);\n\n this.notifyBelongsToChange();\n };\n\n _proto.removeRecordDataFromOwn = function removeRecordDataFromOwn(recordData) {\n if (!this.members.has(recordData)) {\n return;\n }\n\n this.inverseRecordData = null;\n\n _Relationship.prototype.removeRecordDataFromOwn.call(this, recordData);\n\n this.notifyBelongsToChange();\n };\n\n _proto.removeAllRecordDatasFromOwn = function removeAllRecordDatasFromOwn() {\n _Relationship.prototype.removeAllRecordDatasFromOwn.call(this);\n\n this.inverseRecordData = null;\n this.notifyBelongsToChange();\n };\n\n _proto.notifyBelongsToChange = function notifyBelongsToChange() {\n var recordData = this.recordData;\n var storeWrapper = this.recordData.storeWrapper;\n storeWrapper.notifyBelongsToChange(recordData.modelName, recordData.id, recordData.clientId, this.key);\n };\n\n _proto.removeCanonicalRecordDataFromOwn = function removeCanonicalRecordDataFromOwn(recordData, idx) {\n if (!this.canonicalMembers.has(recordData)) {\n return;\n }\n\n this.canonicalState = null;\n this.setHasAnyRelationshipData(true);\n this.setRelationshipIsEmpty(true);\n\n _Relationship.prototype.removeCanonicalRecordDataFromOwn.call(this, recordData, idx);\n };\n\n _proto.removeAllCanonicalRecordDatasFromOwn = function removeAllCanonicalRecordDatasFromOwn() {\n _Relationship.prototype.removeAllCanonicalRecordDatasFromOwn.call(this);\n\n this.canonicalState = null;\n };\n\n _proto.getData = function getData() {\n var data;\n var payload = {};\n\n if (this.inverseRecordData) {\n data = this.inverseRecordData.getResourceIdentifier();\n }\n\n if (this.inverseRecordData === null && this.hasAnyRelationshipData) {\n data = null;\n }\n\n if (this.links) {\n payload.links = this.links;\n }\n\n if (data !== undefined) {\n payload.data = data;\n }\n\n if (this.meta) {\n payload.meta = this.meta;\n }\n\n payload._relationship = this;\n return payload;\n };\n\n _proto.updateData = function updateData(data) {\n var recordData;\n\n if (Ember.isNone(data)) {\n recordData = null;\n }\n\n ( !(data === null || data.id !== undefined && data.type !== undefined) && Ember.assert(\"Ember Data expected the data for the \" + this.key + \" relationship on a \" + this.recordData.toString() + \" to be in a JSON API format and include an `id` and `type` property but it found \" + Ember.inspect(data) + \". Please check your serializer and make sure it is serializing the relationship payload into a JSON API format.\", data === null || data.id !== undefined && data.type !== undefined));\n\n if (recordData !== null) {\n recordData = this.recordData.storeWrapper.recordDataFor(data.type, data.id);\n }\n\n this.setCanonicalRecordData(recordData);\n };\n\n return BelongsToRelationship;\n }(Relationship);\n\n function _inheritsLoose$2(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf$2(subClass, superClass); }\n\n function _setPrototypeOf$2(o, p) { _setPrototypeOf$2 = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$2(o, p); }\n\n /**\n @module @ember-data/record-data\n */\n var ManyRelationship = /*#__PURE__*/function (_Relationship) {\n _inheritsLoose$2(ManyRelationship, _Relationship);\n\n function ManyRelationship(store, inverseKey, relationshipMeta, recordData, inverseIsAsync) {\n var _this;\n\n _this = _Relationship.call(this, store, inverseKey, relationshipMeta, recordData, inverseIsAsync) || this; // persisted state\n\n _this.canonicalState = void 0;\n _this.currentState = void 0;\n _this._willUpdateManyArray = void 0;\n _this._pendingManyArrayUpdates = void 0;\n _this.key = void 0;\n _this.canonicalState = []; // local client state\n\n _this.currentState = [];\n _this._willUpdateManyArray = false;\n _this._pendingManyArrayUpdates = null;\n _this.key = relationshipMeta.key;\n return _this;\n }\n\n var _proto = ManyRelationship.prototype;\n\n _proto.addCanonicalRecordData = function addCanonicalRecordData(recordData, idx) {\n if (this.canonicalMembers.has(recordData)) {\n return;\n }\n\n if (idx !== undefined) {\n this.canonicalState.splice(idx, 0, recordData);\n } else {\n this.canonicalState.push(recordData);\n }\n\n _Relationship.prototype.addCanonicalRecordData.call(this, recordData, idx);\n };\n\n _proto.inverseDidDematerialize = function inverseDidDematerialize(inverseRecordData) {\n _Relationship.prototype.inverseDidDematerialize.call(this, inverseRecordData);\n\n if (this.isAsync) {\n this.notifyManyArrayIsStale();\n }\n };\n\n _proto.addRecordData = function addRecordData(recordData, idx) {\n if (this.members.has(recordData)) {\n return;\n } // TODO Type this\n\n\n Debug.assertPolymorphicType(this.recordData, this.relationshipMeta, recordData, this.store);\n\n _Relationship.prototype.addRecordData.call(this, recordData, idx); // make lazy later\n\n\n if (idx === undefined) {\n idx = this.currentState.length;\n }\n\n this.currentState.splice(idx, 0, recordData); // TODO Igor consider making direct to remove the indirection\n // We are not lazily accessing the manyArray here because the change is coming from app side\n // this.manyArray.flushCanonical(this.currentState);\n\n this.notifyHasManyChange();\n };\n\n _proto.removeCanonicalRecordDataFromOwn = function removeCanonicalRecordDataFromOwn(recordData, idx) {\n var i = idx;\n\n if (!this.canonicalMembers.has(recordData)) {\n return;\n }\n\n if (i === undefined) {\n i = this.canonicalState.indexOf(recordData);\n }\n\n if (i > -1) {\n this.canonicalState.splice(i, 1);\n }\n\n _Relationship.prototype.removeCanonicalRecordDataFromOwn.call(this, recordData, idx); //TODO(Igor) Figure out what to do here\n\n };\n\n _proto.removeAllCanonicalRecordDatasFromOwn = function removeAllCanonicalRecordDatasFromOwn() {\n _Relationship.prototype.removeAllCanonicalRecordDatasFromOwn.call(this);\n\n this.canonicalMembers.clear();\n this.canonicalState.splice(0, this.canonicalState.length);\n\n _Relationship.prototype.removeAllCanonicalRecordDatasFromOwn.call(this);\n } //TODO(Igor) DO WE NEED THIS?\n ;\n\n _proto.removeCompletelyFromOwn = function removeCompletelyFromOwn(recordData) {\n _Relationship.prototype.removeCompletelyFromOwn.call(this, recordData); // TODO SkEPTICAL\n\n\n var canonicalIndex = this.canonicalState.indexOf(recordData);\n\n if (canonicalIndex !== -1) {\n this.canonicalState.splice(canonicalIndex, 1);\n }\n\n this.removeRecordDataFromOwn(recordData);\n };\n\n _proto.flushCanonical = function flushCanonical() {\n var toSet = this.canonicalState; //a hack for not removing new records\n //TODO remove once we have proper diffing\n\n var newRecordDatas = this.currentState.filter( // only add new internalModels which are not yet in the canonical state of this\n // relationship (a new internalModel can be in the canonical state if it has\n // been 'acknowleged' to be in the relationship via a store.push)\n //TODO Igor deal with this\n function (recordData) {\n return recordData.isNew() && toSet.indexOf(recordData) === -1;\n });\n toSet = toSet.concat(newRecordDatas);\n /*\n if (this._manyArray) {\n this._manyArray.flushCanonical(toSet);\n }\n */\n\n this.currentState = toSet;\n\n _Relationship.prototype.flushCanonical.call(this); // Once we clean up all the flushing, we will be left with at least the notifying part\n\n\n this.notifyHasManyChange();\n } //TODO(Igor) idx not used currently, fix\n ;\n\n _proto.removeRecordDataFromOwn = function removeRecordDataFromOwn(recordData, idx) {\n _Relationship.prototype.removeRecordDataFromOwn.call(this, recordData, idx);\n\n var index = idx || this.currentState.indexOf(recordData); //TODO IGOR DAVID INVESTIGATE\n\n if (index === -1) {\n return;\n }\n\n this.currentState.splice(index, 1); // TODO Igor consider making direct to remove the indirection\n // We are not lazily accessing the manyArray here because the change is coming from app side\n\n this.notifyHasManyChange(); // this.manyArray.flushCanonical(this.currentState);\n };\n\n _proto.notifyRecordRelationshipAdded = function notifyRecordRelationshipAdded() {\n this.notifyHasManyChange();\n };\n\n _proto.computeChanges = function computeChanges(recordDatas) {\n if (recordDatas === void 0) {\n recordDatas = [];\n }\n\n var members = this.canonicalMembers.toArray();\n\n for (var i = members.length - 1; i >= 0; i--) {\n this.removeCanonicalRecordData(members[i], i);\n }\n\n for (var _i = 0, l = recordDatas.length; _i < l; _i++) {\n this.addCanonicalRecordData(recordDatas[_i], _i);\n }\n }\n /*\n This is essentially a \"sync\" version of\n notifyHasManyChange. We should work to unify\n these worlds\n - @runspired\n */\n ;\n\n _proto.notifyManyArrayIsStale = function notifyManyArrayIsStale() {\n var recordData = this.recordData;\n var storeWrapper = recordData.storeWrapper;\n\n {\n storeWrapper.notifyPropertyChange(recordData.modelName, recordData.id, recordData.clientId, this.key);\n }\n };\n\n _proto.notifyHasManyChange = function notifyHasManyChange() {\n var recordData = this.recordData;\n var storeWrapper = recordData.storeWrapper;\n storeWrapper.notifyHasManyChange(recordData.modelName, recordData.id, recordData.clientId, this.key);\n };\n\n _proto.getData = function getData() {\n var payload = {};\n\n if (this.hasAnyRelationshipData) {\n payload.data = this.currentState.map(function (recordData) {\n return recordData.getResourceIdentifier();\n });\n }\n\n if (this.links) {\n payload.links = this.links;\n }\n\n if (this.meta) {\n payload.meta = this.meta;\n } // TODO @runspired: the @igor refactor is too limiting for relationship state\n // we should reconsider where we fetch from.\n\n\n payload._relationship = this;\n return payload;\n };\n\n _proto.updateData = function updateData(data) {\n var recordDatas;\n\n if (Ember.isNone(data)) {\n recordDatas = undefined;\n } else {\n recordDatas = new Array(data.length);\n\n for (var i = 0; i < data.length; i++) {\n recordDatas[i] = this.recordData.storeWrapper.recordDataFor(data[i].type, data[i].id, data[i].lid);\n }\n }\n\n this.updateRecordDatasFromAdapter(recordDatas);\n };\n\n return ManyRelationship;\n }(Relationship);\n\n function createRelationshipFor(relationshipMeta, store, recordData, key) {\n var inverseKey = recordData.storeWrapper.inverseForRelationship(recordData.modelName, key);\n var inverseIsAsync = recordData.storeWrapper.inverseIsAsyncForRelationship(recordData.modelName, key);\n\n if (relationshipMeta.kind === 'hasMany') {\n return new ManyRelationship(store, inverseKey, relationshipMeta, recordData, inverseIsAsync);\n } else {\n return new BelongsToRelationship(store, inverseKey, relationshipMeta, recordData, inverseIsAsync);\n }\n }\n\n var Relationships = /*#__PURE__*/function () {\n function Relationships(recordData) {\n this._store = void 0;\n this._storeWrapper = void 0;\n this.initializedRelationships = void 0;\n this.recordData = recordData;\n this.initializedRelationships = Object.create(null);\n this._storeWrapper = Private.upgradeForInternal(recordData.storeWrapper);\n this._store = this._storeWrapper._store;\n }\n\n var _proto = Relationships.prototype;\n\n _proto.has = function has(key) {\n return !!this.initializedRelationships[key];\n };\n\n _proto.forEach = function forEach(cb) {\n var rels = this.initializedRelationships;\n Object.keys(rels).forEach(function (name) {\n cb(name, rels[name]);\n });\n };\n\n _proto.get = function get(key) {\n var relationships = this.initializedRelationships;\n var relationship = relationships[key];\n\n if (!relationship) {\n var _recordData = this.recordData;\n var rel = this.recordData.storeWrapper.relationshipsDefinitionFor(this.recordData.modelName)[key];\n\n if (rel) {\n // lazily instantiate relationship\n relationship = relationships[key] = createRelationshipFor(rel, this._store, _recordData, key);\n }\n }\n\n return relationship;\n };\n\n return Relationships;\n }();\n\n function _defineProperties$1(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\n function _createClass$1(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1(Constructor, staticProps); return Constructor; }\n var nextBfsId = 1;\n\n var RecordDataDefault = /*#__PURE__*/function () {\n function RecordDataDefault(identifier, storeWrapper) {\n var _this = this;\n\n this._errors = void 0;\n this.__relationships = void 0;\n this.__implicitRelationships = void 0;\n this.modelName = void 0;\n this.clientId = void 0;\n this.id = void 0;\n this.isDestroyed = void 0;\n this._isNew = void 0;\n this._bfsId = void 0;\n this.__attributes = void 0;\n this.__inFlightAttributes = void 0;\n this.__data = void 0;\n this._scheduledDestroy = void 0;\n this._isDeleted = void 0;\n this._isDeletionCommited = void 0;\n\n this._directlyRelatedRecordDatasIterable = function () {\n var initializedRelationships = _this._relationships.initializedRelationships;\n var relationships = Object.keys(initializedRelationships).map(function (key) {\n return initializedRelationships[key];\n });\n var i = 0;\n var j = 0;\n var k = 0;\n\n var findNext = function findNext() {\n while (i < relationships.length) {\n while (j < 2) {\n var members = j === 0 ? relationships[i].members.list : relationships[i].canonicalMembers.list;\n\n while (k < members.length) {\n return members[k++];\n }\n\n k = 0;\n j++;\n }\n\n j = 0;\n i++;\n }\n\n return undefined;\n };\n\n return {\n iterator: function iterator() {\n return {\n next: function next() {\n var value = findNext();\n return {\n value: value,\n done: value === undefined\n };\n }\n };\n }\n };\n };\n\n this.identifier = identifier;\n this.storeWrapper = storeWrapper;\n this.modelName = identifier.type;\n this.clientId = identifier.lid;\n this.id = identifier.id;\n this.__relationships = null;\n this.__implicitRelationships = null;\n this.isDestroyed = false;\n this._isNew = false;\n this._isDeleted = false; // Used during the mark phase of unloading to avoid checking the same internal\n // model twice in the same scan\n\n this._bfsId = 0;\n this.reset();\n } // PUBLIC API\n\n\n var _proto = RecordDataDefault.prototype;\n\n _proto.getResourceIdentifier = function getResourceIdentifier() {\n return this.identifier;\n };\n\n _proto.pushData = function pushData(data, calculateChange) {\n var changedKeys;\n\n if (this._isNew) {\n this._isNew = false;\n this.notifyStateChange();\n }\n\n if (calculateChange) {\n changedKeys = this._changedKeys(data.attributes);\n }\n\n Ember.assign(this._data, data.attributes);\n\n if (this.__attributes) {\n // only do if we have attribute changes\n this._updateChangedAttributes();\n }\n\n if (data.relationships) {\n this._setupRelationships(data);\n }\n\n if (data.id) {\n this.id = coerceId(data.id);\n }\n\n return changedKeys;\n };\n\n _proto.willCommit = function willCommit() {\n this._inFlightAttributes = this._attributes;\n this._attributes = null;\n };\n\n _proto.hasChangedAttributes = function hasChangedAttributes() {\n return this.__attributes !== null && Object.keys(this.__attributes).length > 0;\n };\n\n _proto._clearErrors = function _clearErrors() {\n };\n\n _proto.getErrors = function getErrors() {\n ( Ember.assert('Can not call getErrors unless the RECORD_DATA_ERRORS feature flag is on', !!false));\n\n {\n return [];\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 ;\n\n _proto.isEmpty = function isEmpty() {\n return this.__attributes === null && this.__inFlightAttributes === null && this.__data === null;\n };\n\n _proto.deleteRecord = function deleteRecord() {\n this._isDeleted = true;\n this.notifyStateChange();\n };\n\n _proto.isDeleted = function isDeleted() {\n return this._isDeleted;\n };\n\n _proto.setIsDeleted = function setIsDeleted(isDeleted) {\n this._isDeleted = isDeleted;\n\n if (this._isNew) {\n this._deletionConfirmed();\n }\n\n this.notifyStateChange();\n };\n\n _proto.isDeletionCommitted = function isDeletionCommitted() {\n return this._isDeletionCommited;\n };\n\n _proto.reset = function reset() {\n this.__attributes = null;\n this.__inFlightAttributes = null;\n this.__data = null;\n this._errors = undefined;\n };\n\n _proto._setupRelationships = function _setupRelationships(data) {\n var relationships = this.storeWrapper.relationshipsDefinitionFor(this.modelName);\n var keys = Object.keys(relationships);\n\n for (var i = 0; i < keys.length; i++) {\n var relationshipName = keys[i];\n\n if (!data.relationships[relationshipName]) {\n continue;\n } // in debug, assert payload validity eagerly\n\n\n var relationshipData = data.relationships[relationshipName];\n\n {\n var _storeWrapper = this.storeWrapper;\n var recordData = this;\n var relationshipMeta = relationships[relationshipName];\n\n if (!relationshipData || !relationshipMeta) {\n continue;\n }\n\n if (relationshipData.links) {\n var isAsync = relationshipMeta.options && relationshipMeta.options.async !== false;\n\n var _relationship = this._relationships.get(relationshipName);\n\n ( Ember.warn(\"You pushed a record of type '\" + this.modelName + \"' with a relationship '\" + relationshipName + \"' 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 || relationshipData.data || _relationship.hasAnyRelationshipData, {\n id: 'ds.store.push-link-for-sync-relationship'\n }));\n } else if (relationshipData.data) {\n if (relationshipMeta.kind === 'belongsTo') {\n ( !(!Array.isArray(relationshipData.data)) && Ember.assert(\"A \" + this.modelName + \" record was pushed into the store with the value of \" + relationshipName + \" being \" + Ember.inspect(relationshipData.data) + \", but \" + relationshipName + \" is a belongsTo relationship so the value must not be an array. You should probably check your data payload or serializer.\", !Array.isArray(relationshipData.data)));\n assertRelationshipData(_storeWrapper, recordData, relationshipData.data, relationshipMeta);\n } else if (relationshipMeta.kind === 'hasMany') {\n ( !(Array.isArray(relationshipData.data)) && Ember.assert(\"A \" + this.modelName + \" record was pushed into the store with the value of \" + relationshipName + \" being '\" + Ember.inspect(relationshipData.data) + \"', but \" + relationshipName + \" is a hasMany relationship so the value must be an array. You should probably check your data payload or serializer.\", Array.isArray(relationshipData.data)));\n\n if (Array.isArray(relationshipData.data)) {\n for (var _i = 0; _i < relationshipData.data.length; _i++) {\n assertRelationshipData(_storeWrapper, recordData, relationshipData.data[_i], relationshipMeta);\n }\n }\n }\n }\n }\n\n var relationship = this._relationships.get(relationshipName);\n\n relationship.push(relationshipData);\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 ;\n\n _proto._updateChangedAttributes = function _updateChangedAttributes() {\n var changedAttributes = this.changedAttributes();\n var changedAttributeNames = Object.keys(changedAttributes);\n var attrs = this._attributes;\n\n for (var i = 0, length = changedAttributeNames.length; i < length; i++) {\n var attribute = changedAttributeNames[i];\n var data = changedAttributes[attribute];\n var oldData = data[0];\n var newData = data[1];\n\n if (oldData === newData) {\n delete attrs[attribute];\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 ;\n\n _proto.changedAttributes = function changedAttributes() {\n var oldData = this._data;\n var currentData = this._attributes;\n var inFlightData = this._inFlightAttributes;\n var newData = Ember.assign({}, inFlightData, currentData);\n var diffData = Object.create(null);\n var newDataKeys = Object.keys(newData);\n\n for (var i = 0, length = newDataKeys.length; i < length; i++) {\n var _key = newDataKeys[i];\n diffData[_key] = [oldData[_key], newData[_key]];\n }\n\n return diffData;\n };\n\n _proto.isNew = function isNew() {\n return this._isNew;\n };\n\n _proto.rollbackAttributes = function rollbackAttributes() {\n var dirtyKeys;\n this._isDeleted = false;\n\n if (this.hasChangedAttributes()) {\n dirtyKeys = Object.keys(this._attributes);\n this._attributes = null;\n }\n\n if (this.isNew()) {\n this.removeFromInverseRelationships(true);\n this._isDeleted = true;\n this._isNew = false;\n }\n\n this._inFlightAttributes = null;\n\n this._clearErrors();\n\n this.notifyStateChange();\n return dirtyKeys;\n };\n\n _proto._deletionConfirmed = function _deletionConfirmed() {\n this.removeFromInverseRelationships();\n };\n\n _proto.didCommit = function didCommit(data) {\n if (this._isDeleted) {\n this._deletionConfirmed();\n\n this._isDeletionCommited = true;\n }\n\n this._isNew = false;\n var newCanonicalAttributes = null;\n\n if (data) {\n // this.store._internalModelDidReceiveRelationshipData(this.modelName, this.id, data.relationships);\n if (data.relationships) {\n this._setupRelationships(data);\n }\n\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\n newCanonicalAttributes = data.attributes || null;\n }\n\n var changedKeys = this._changedKeys(newCanonicalAttributes);\n\n Ember.assign(this._data, this.__inFlightAttributes, newCanonicalAttributes);\n this._inFlightAttributes = null;\n\n this._updateChangedAttributes();\n\n this._clearErrors();\n\n this.notifyStateChange();\n return changedKeys;\n };\n\n _proto.notifyStateChange = function notifyStateChange() {\n } // get ResourceIdentifiers for \"current state\"\n ;\n\n _proto.getHasMany = function getHasMany(key) {\n return this._relationships.get(key).getData();\n } // set a new \"current state\" via ResourceIdentifiers\n ;\n\n _proto.setDirtyHasMany = function setDirtyHasMany(key, recordDatas) {\n var relationship = this._relationships.get(key);\n\n relationship.clear();\n relationship.addRecordDatas(recordDatas);\n } // append to \"current state\" via RecordDatas\n ;\n\n _proto.addToHasMany = function addToHasMany(key, recordDatas, idx) {\n this._relationships.get(key).addRecordDatas(recordDatas, idx);\n } // remove from \"current state\" via RecordDatas\n ;\n\n _proto.removeFromHasMany = function removeFromHasMany(key, recordDatas) {\n this._relationships.get(key).removeRecordDatas(recordDatas);\n };\n\n _proto.commitWasRejected = function commitWasRejected(identifier, errors) {\n var keys = Object.keys(this._inFlightAttributes);\n\n if (keys.length > 0) {\n var attrs = this._attributes;\n\n for (var i = 0; i < keys.length; i++) {\n if (attrs[keys[i]] === undefined) {\n attrs[keys[i]] = this._inFlightAttributes[keys[i]];\n }\n }\n }\n\n this._inFlightAttributes = null;\n };\n\n _proto.getBelongsTo = function getBelongsTo(key) {\n return this._relationships.get(key).getData();\n };\n\n _proto.setDirtyBelongsTo = function setDirtyBelongsTo(key, recordData) {\n this._relationships.get(key).setRecordData(recordData);\n };\n\n _proto.setDirtyAttribute = function setDirtyAttribute(key, value) {\n var originalValue; // Add the new value to the changed attributes hash\n\n this._attributes[key] = value;\n\n if (key in this._inFlightAttributes) {\n originalValue = this._inFlightAttributes[key];\n } else {\n originalValue = this._data[key];\n } // If we went back to our original value, we shouldn't keep the attribute around anymore\n\n\n if (value === originalValue) {\n delete this._attributes[key];\n }\n } // internal set coming from the model\n ;\n\n _proto.__setId = function __setId(id) {\n if (this.id !== id) {\n this.id = id;\n }\n };\n\n _proto.getAttr = function 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\n _proto.hasAttr = function hasAttr(key) {\n return key in this._attributes || key in this._inFlightAttributes || key in this._data;\n };\n\n _proto.unloadRecord = function unloadRecord() {\n if (this.isDestroyed) {\n return;\n }\n\n this._destroyRelationships();\n\n this.reset();\n\n if (!this._scheduledDestroy) {\n this._scheduledDestroy = Ember.run.backburner.schedule('destroy', this, '_cleanupOrphanedRecordDatas');\n }\n };\n\n _proto._cleanupOrphanedRecordDatas = function _cleanupOrphanedRecordDatas() {\n var relatedRecordDatas = this._allRelatedRecordDatas();\n\n if (areAllModelsUnloaded(relatedRecordDatas)) {\n for (var i = 0; i < relatedRecordDatas.length; ++i) {\n var recordData = relatedRecordDatas[i];\n\n if (!recordData.isDestroyed) {\n recordData.destroy();\n }\n }\n }\n\n this._scheduledDestroy = null;\n };\n\n _proto.destroy = function destroy() {\n this._relationships.forEach(function (name, rel) {\n return rel.destroy();\n });\n\n this.isDestroyed = true;\n this.storeWrapper.disconnectRecord(this.modelName, this.id, this.clientId);\n };\n\n _proto.isRecordInUse = function isRecordInUse() {\n return this.storeWrapper.isRecordInUse(this.modelName, this.id, this.clientId);\n }\n /**\n Iterates over the set of internal models reachable from `this` across exactly one\n relationship.\n */\n ;\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 @return {Array} An array including `this` and all internal models reachable\n from `this`.\n */\n _proto._allRelatedRecordDatas = function _allRelatedRecordDatas() {\n var array = [];\n var queue = [];\n var bfsId = nextBfsId++;\n queue.push(this);\n this._bfsId = bfsId;\n\n while (queue.length > 0) {\n var node = queue.shift();\n array.push(node);\n\n var iterator = this._directlyRelatedRecordDatasIterable().iterator();\n\n for (var obj = iterator.next(); !obj.done; obj = iterator.next()) {\n var recordData = obj.value;\n\n if (recordData instanceof RecordDataDefault) {\n ( !(recordData._bfsId <= bfsId) && Ember.assert('Internal Error: seen a future bfs iteration', recordData._bfsId <= bfsId));\n\n if (recordData._bfsId < bfsId) {\n queue.push(recordData);\n recordData._bfsId = bfsId;\n }\n }\n }\n }\n\n return array;\n };\n\n _proto.isAttrDirty = function isAttrDirty(key) {\n if (this._attributes[key] === undefined) {\n return false;\n }\n\n var originalValue;\n\n if (this._inFlightAttributes[key] !== undefined) {\n originalValue = this._inFlightAttributes[key];\n } else {\n originalValue = this._data[key];\n }\n\n return originalValue !== this._attributes[key];\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 * @param options\n * @private\n */\n _proto._initRecordCreateOptions = function _initRecordCreateOptions(options) {\n var createOptions = {};\n\n if (options !== undefined) {\n var modelName = this.modelName,\n _storeWrapper2 = this.storeWrapper;\n\n var attributeDefs = _storeWrapper2.attributesDefinitionFor(modelName);\n\n var relationshipDefs = _storeWrapper2.relationshipsDefinitionFor(modelName);\n\n var relationships = this._relationships;\n var propertyNames = Object.keys(options);\n\n for (var i = 0; i < propertyNames.length; i++) {\n var name = propertyNames[i];\n var propertyValue = options[name];\n\n if (name === 'id') {\n this.id = propertyValue;\n continue;\n }\n\n var fieldType = relationshipDefs[name] || attributeDefs[name];\n var kind = fieldType !== undefined ? fieldType.kind : null;\n var relationship = void 0;\n\n switch (kind) {\n case 'attribute':\n this.setDirtyAttribute(name, propertyValue);\n break;\n\n case 'belongsTo':\n this.setDirtyBelongsTo(name, propertyValue);\n relationship = relationships.get(name);\n relationship.setHasAnyRelationshipData(true);\n relationship.setRelationshipIsEmpty(false);\n break;\n\n case 'hasMany':\n this.setDirtyHasMany(name, propertyValue);\n relationship = relationships.get(name);\n relationship.setHasAnyRelationshipData(true);\n relationship.setRelationshipIsEmpty(false);\n break;\n\n default:\n // reflect back (pass-thru) unknown properties\n createOptions[name] = propertyValue;\n }\n }\n }\n\n return createOptions;\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 ;\n\n _proto.removeFromInverseRelationships = function removeFromInverseRelationships(isNew) {\n if (isNew === void 0) {\n isNew = false;\n }\n\n this._relationships.forEach(function (name, rel) {\n rel.removeCompletelyFromInverse();\n\n if (isNew === true) {\n rel.clear();\n }\n });\n\n this.__relationships = null;\n var implicitRelationships = this._implicitRelationships;\n this.__implicitRelationships = null;\n Object.keys(implicitRelationships).forEach(function (key) {\n var rel = implicitRelationships[key];\n rel.removeCompletelyFromInverse();\n\n if (isNew === true) {\n rel.clear();\n }\n });\n };\n\n _proto._destroyRelationships = function _destroyRelationships() {\n var relationships = this._relationships;\n relationships.forEach(function (name, rel) {\n return destroyRelationship(rel);\n });\n var implicitRelationships = this._implicitRelationships;\n this.__implicitRelationships = null;\n Object.keys(implicitRelationships).forEach(function (key) {\n var rel = implicitRelationships[key];\n destroyRelationship(rel);\n });\n };\n\n _proto.clientDidCreate = function clientDidCreate() {\n this._isNew = true;\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 /*\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 ;\n\n _proto._changedKeys = function _changedKeys(updates) {\n var changedKeys = [];\n\n if (updates) {\n var original, i, value, _key2;\n\n var keys = Object.keys(updates);\n var length = keys.length;\n var hasAttrs = this.hasChangedAttributes();\n var attrs;\n\n if (hasAttrs) {\n attrs = this._attributes;\n }\n\n original = Ember.assign(Object.create(null), this._data, this.__inFlightAttributes);\n\n for (i = 0; i < length; i++) {\n _key2 = keys[i];\n value = updates[_key2]; // 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\n if (hasAttrs === true && attrs[_key2] !== undefined) {\n continue;\n }\n\n if (!Ember.isEqual(original[_key2], value)) {\n changedKeys.push(_key2);\n }\n }\n }\n\n return changedKeys;\n };\n\n _proto.toString = function toString() {\n return \"<\" + this.modelName + \":\" + this.id + \">\";\n };\n\n _createClass$1(RecordDataDefault, [{\n key: \"_attributes\",\n get: function get() {\n if (this.__attributes === null) {\n this.__attributes = Object.create(null);\n }\n\n return this.__attributes;\n },\n set: function set(v) {\n this.__attributes = v;\n }\n }, {\n key: \"_relationships\",\n get: function get() {\n if (this.__relationships === null) {\n this.__relationships = new Relationships(this);\n }\n\n return this.__relationships;\n }\n }, {\n key: \"_data\",\n get: function get() {\n if (this.__data === null) {\n this.__data = Object.create(null);\n }\n\n return this.__data;\n },\n set: function set(v) {\n this.__data = v;\n }\n /*\n implicit relationships are relationship 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 Model.extend({\n name: attr()\n });\n ```\n but there is also\n ```app/models/post.js\n import Model, { attr, hasMany } from '@ember-data/model';\n export default Model.extend({\n name: attr(),\n comments: hasMany('comment')\n });\n ```\n would have a implicit post relationship in order to be do things like remove ourselves from the post\n when we are deleted\n */\n\n }, {\n key: \"_implicitRelationships\",\n get: function get() {\n if (this.__implicitRelationships === null) {\n var relationships = Object.create(null);\n this.__implicitRelationships = relationships;\n return relationships;\n }\n\n return this.__implicitRelationships;\n }\n }, {\n key: \"_inFlightAttributes\",\n get: function get() {\n if (this.__inFlightAttributes === null) {\n this.__inFlightAttributes = Object.create(null);\n }\n\n return this.__inFlightAttributes;\n },\n set: function set(v) {\n this.__inFlightAttributes = v;\n }\n }]);\n\n return RecordDataDefault;\n }();\n\n function assertRelationshipData(store, recordData, data, meta) {\n ( !(!Array.isArray(data)) && Ember.assert(\"A \" + recordData.modelName + \" 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) && Ember.assert(\"Encountered a relationship identifier without a type for the \" + meta.kind + \" relationship '\" + meta.key + \"' on \" + recordData + \", 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 || !!coerceId(data.id)) && Ember.assert(\"Encountered a relationship identifier without an id for the \" + meta.kind + \" relationship '\" + meta.key + \"' on \" + recordData + \", 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 || !!coerceId(data.id)));\n ( !(data === null || !data.type || store._hasModelFor(data.type)) && Ember.assert(\"Encountered a relationship identifier with type '\" + data.type + \"' for the \" + meta.kind + \" relationship '\" + meta.key + \"' on \" + recordData + \", 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 } // 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\n\n function destroyRelationship(rel) {\n rel.recordDataDidDematerialize();\n\n if (rel._inverseIsSync()) {\n rel.removeAllRecordDatasFromOwn();\n rel.removeAllCanonicalRecordDatasFromOwn();\n }\n }\n\n function areAllModelsUnloaded(recordDatas) {\n for (var i = 0; i < recordDatas.length; ++i) {\n if (recordDatas[i].isRecordInUse()) {\n return false;\n }\n }\n\n return true;\n }\n\n exports.BelongsToRelationship = BelongsToRelationship;\n exports.ManyRelationship = ManyRelationship;\n exports.RecordData = RecordDataDefault;\n exports.Relationship = Relationship;\n exports.relationshipStateFor = relationshipStateFor;\n exports.relationshipsFor = relationshipsFor;\n\n Object.defineProperty(exports, '__esModule', { value: true });\n\n});\n","define('@ember-data/serializer/-private', ['exports', '@ember/string'], function (exports, string$1) { 'use strict';\n\n /**\n @module @ember-data/serializer\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 */\n var embeddedRecordsMixin = Ember.Mixin.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 @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: function normalize(typeClass, hash, prop) {\n var normalizedHash = this._super(typeClass, hash, prop);\n\n return this._extractEmbeddedRecords(this, this.store, typeClass, normalizedHash);\n },\n keyForRelationship: function 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 /**\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 @param {Snapshot} snapshot\n @param {Object} json\n @param {Object} relationship\n */\n serializeBelongsTo: function serializeBelongsTo(snapshot, json, relationship) {\n var attr = relationship.key;\n\n if (this.noSerializeOptionSpecified(attr)) {\n this._super(snapshot, json, relationship);\n\n return;\n }\n\n var includeIds = this.hasSerializeIdsOption(attr);\n var includeRecords = this.hasSerializeRecordsOption(attr);\n var embeddedSnapshot = snapshot.belongsTo(attr);\n\n if (includeIds) {\n var serializedKey = this._getMappedKey(relationship.key, snapshot.type);\n\n if (serializedKey === relationship.key && this.keyForRelationship) {\n serializedKey = this.keyForRelationship(relationship.key, relationship.kind, 'serialize');\n }\n\n if (!embeddedSnapshot) {\n json[serializedKey] = null;\n } else {\n json[serializedKey] = embeddedSnapshot.id;\n\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: function _serializeEmbeddedBelongsTo(snapshot, json, relationship) {\n var embeddedSnapshot = snapshot.belongsTo(relationship.key);\n\n var serializedKey = this._getMappedKey(relationship.key, snapshot.type);\n\n if (serializedKey === relationship.key && this.keyForRelationship) {\n serializedKey = this.keyForRelationship(relationship.key, relationship.kind, 'serialize');\n }\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\n if (relationship.options.polymorphic) {\n this.serializePolymorphicType(snapshot, json, relationship);\n }\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 @param {Snapshot} snapshot\n @param {Object} json\n @param {Object} relationship\n */\n serializeHasMany: function serializeHasMany(snapshot, json, relationship) {\n var attr = relationship.key;\n\n if (this.noSerializeOptionSpecified(attr)) {\n this._super(snapshot, json, relationship);\n\n return;\n }\n\n if (this.hasSerializeIdsOption(attr)) {\n var serializedKey = this._getMappedKey(relationship.key, snapshot.type);\n\n if (serializedKey === relationship.key && this.keyForRelationship) {\n serializedKey = this.keyForRelationship(relationship.key, relationship.kind, 'serialize');\n }\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 /*\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: function _serializeHasManyAsIdsAndTypes(snapshot, json, relationship) {\n var serializedKey = this.keyForAttribute(relationship.key, 'serialize');\n var hasMany = snapshot.hasMany(relationship.key);\n json[serializedKey] = Ember.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: function _serializeEmbeddedHasMany(snapshot, json, relationship) {\n var serializedKey = this._getMappedKey(relationship.key, snapshot.type);\n\n if (serializedKey === relationship.key && this.keyForRelationship) {\n serializedKey = this.keyForRelationship(relationship.key, relationship.kind, 'serialize');\n }\n\n ( Ember.warn(\"The embedded relationship '\" + serializedKey + \"' is undefined for '\" + snapshot.modelName + \"' with id '\" + snapshot.id + \"'. Please include it in your original payload.\", Ember.typeOf(snapshot.hasMany(relationship.key)) !== 'undefined', {\n id: 'ds.serializer.embedded-relationship-undefined'\n }));\n json[serializedKey] = this._generateSerializedHasMany(snapshot, relationship);\n },\n\n /*\n Returns an array of embedded records serialized to JSON\n */\n _generateSerializedHasMany: function _generateSerializedHasMany(snapshot, relationship) {\n var hasMany = snapshot.hasMany(relationship.key);\n var manyArray = Ember.A(hasMany);\n var ret = new Array(manyArray.length);\n\n for (var i = 0; i < manyArray.length; i++) {\n var embeddedSnapshot = manyArray[i];\n var embeddedJson = embeddedSnapshot.serialize({\n includeId: true\n });\n this.removeEmbeddedForeignKey(snapshot, embeddedSnapshot, relationship, embeddedJson);\n ret[i] = embeddedJson;\n }\n\n return ret;\n },\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 @param {Snapshot} snapshot\n @param {Snapshot} embeddedSnapshot\n @param {Object} relationship\n @param {Object} json\n */\n removeEmbeddedForeignKey: function removeEmbeddedForeignKey(snapshot, embeddedSnapshot, relationship, json) {\n if (relationship.kind === 'belongsTo') {\n var parentRecord = snapshot.type.inverseFor(relationship.key, this.store);\n\n if (parentRecord) {\n var name = parentRecord.name;\n var embeddedSerializer = this.store.serializerFor(embeddedSnapshot.modelName);\n var parentKey = embeddedSerializer.keyForRelationship(name, parentRecord.kind, 'deserialize');\n\n if (parentKey) {\n delete json[parentKey];\n }\n }\n }\n /*else if (relationship.kind === 'hasMany') {\n return;\n }*/\n\n },\n // checks config for attrs option to embedded (always) - serialize and deserialize\n hasEmbeddedAlwaysOption: function hasEmbeddedAlwaysOption(attr) {\n var option = this.attrsOption(attr);\n return option && option.embedded === 'always';\n },\n // checks config for attrs option to serialize ids\n hasSerializeRecordsOption: function hasSerializeRecordsOption(attr) {\n var alwaysEmbed = this.hasEmbeddedAlwaysOption(attr);\n var option = this.attrsOption(attr);\n return alwaysEmbed || option && option.serialize === 'records';\n },\n // checks config for attrs option to serialize records\n hasSerializeIdsOption: function hasSerializeIdsOption(attr) {\n var 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: function hasSerializeIdsAndTypesOption(attr) {\n var 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: function noSerializeOptionSpecified(attr) {\n var 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: function hasDeserializeRecordsOption(attr) {\n var alwaysEmbed = this.hasEmbeddedAlwaysOption(attr);\n var option = this.attrsOption(attr);\n return alwaysEmbed || option && option.deserialize === 'records';\n },\n attrsOption: function attrsOption(attr) {\n var attrs = this.get('attrs');\n return attrs && (attrs[string$1.camelize(attr)] || attrs[attr]);\n },\n\n /**\n @method _extractEmbeddedRecords\n @private\n */\n _extractEmbeddedRecords: function _extractEmbeddedRecords(serializer, store, typeClass, partial) {\n var _this = this;\n\n typeClass.eachRelationship(function (key, relationship) {\n if (serializer.hasDeserializeRecordsOption(key)) {\n if (relationship.kind === 'hasMany') {\n _this._extractEmbeddedHasMany(store, key, partial, relationship);\n }\n\n if (relationship.kind === 'belongsTo') {\n _this._extractEmbeddedBelongsTo(store, key, partial, relationship);\n }\n }\n });\n return partial;\n },\n\n /**\n @method _extractEmbeddedHasMany\n @private\n */\n _extractEmbeddedHasMany: function _extractEmbeddedHasMany(store, key, hash, relationshipMeta) {\n var relationshipHash = Ember.get(hash, \"data.relationships.\" + key + \".data\");\n\n if (!relationshipHash) {\n return;\n }\n\n var hasMany = new Array(relationshipHash.length);\n\n for (var i = 0; i < relationshipHash.length; i++) {\n var item = relationshipHash[i];\n\n var _this$_normalizeEmbed = this._normalizeEmbeddedRelationship(store, relationshipMeta, item),\n data = _this$_normalizeEmbed.data,\n included = _this$_normalizeEmbed.included;\n\n hash.included = hash.included || [];\n hash.included.push(data);\n\n if (included) {\n var _hash$included;\n\n (_hash$included = hash.included).push.apply(_hash$included, included);\n }\n\n hasMany[i] = {\n id: data.id,\n type: data.type\n };\n }\n\n var relationship = {\n data: hasMany\n };\n Ember.set(hash, \"data.relationships.\" + key, relationship);\n },\n\n /**\n @method _extractEmbeddedBelongsTo\n @private\n */\n _extractEmbeddedBelongsTo: function _extractEmbeddedBelongsTo(store, key, hash, relationshipMeta) {\n var relationshipHash = Ember.get(hash, \"data.relationships.\" + key + \".data\");\n\n if (!relationshipHash) {\n return;\n }\n\n var _this$_normalizeEmbed2 = this._normalizeEmbeddedRelationship(store, relationshipMeta, relationshipHash),\n data = _this$_normalizeEmbed2.data,\n included = _this$_normalizeEmbed2.included;\n\n hash.included = hash.included || [];\n hash.included.push(data);\n\n if (included) {\n var _hash$included2;\n\n (_hash$included2 = hash.included).push.apply(_hash$included2, included);\n }\n\n var belongsTo = {\n id: data.id,\n type: data.type\n };\n var relationship = {\n data: belongsTo\n };\n Ember.set(hash, \"data.relationships.\" + key, relationship);\n },\n\n /**\n @method _normalizeEmbeddedRelationship\n @private\n */\n _normalizeEmbeddedRelationship: function _normalizeEmbeddedRelationship(store, relationshipMeta, relationshipHash) {\n var modelName = relationshipMeta.type;\n\n if (relationshipMeta.options.polymorphic) {\n modelName = relationshipHash.type;\n }\n\n var modelClass = store.modelFor(modelName);\n var serializer = store.serializerFor(modelName);\n return serializer.normalize(modelClass, relationshipHash, null);\n },\n isEmbeddedRecordsMixin: true\n });\n\n /**\n @module @ember-data/serializer\n */\n\n /*\n Check if the passed model has a `type` attribute or a relationship named `type`.\n\n @method modelHasAttributeOrRelationshipNamedType\n @param modelClass\n */\n function modelHasAttributeOrRelationshipNamedType(modelClass) {\n return Ember.get(modelClass, 'attributes').has('type') || Ember.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 */\n var Transform = Ember.Object.extend({\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 @param deserialized The deserialized value\n @param options hash of options passed to `attr`\n @return The serialized value\n */\n serialize: null,\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 @param serialized The serialized value\n @param options hash of options passed to `attr`\n @return The deserialized value\n */\n deserialize: null\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 @extends Transform\n */\n\n var boolean = Transform.extend({\n deserialize: function deserialize(serialized, options) {\n if (Ember.isNone(serialized) && options.allowNull === true) {\n return null;\n }\n\n var type = typeof serialized;\n\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: function serialize(deserialized, options) {\n if (Ember.isNone(deserialized) && options.allowNull === true) {\n return null;\n }\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 @extends Transform\n */\n\n var date = Transform.extend({\n deserialize: function deserialize(serialized) {\n var type = typeof serialized;\n\n if (type === 'string') {\n var offset = serialized.indexOf('+');\n\n if (offset !== -1 && serialized.length - 5 === offset) {\n offset += 3;\n return new Date(serialized.slice(0, offset) + ':' + serialized.slice(offset));\n }\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: function 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 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 @extends Transform\n */\n\n\n var number = Transform.extend({\n deserialize: function deserialize(serialized) {\n var transformed;\n\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: function serialize(deserialized) {\n var transformed;\n\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 @extends Transform\n */\n\n var string = Transform.extend({\n deserialize: function deserialize(serialized) {\n return Ember.isNone(serialized) ? null : String(serialized);\n },\n serialize: function serialize(deserialized) {\n return Ember.isNone(deserialized) ? null : String(deserialized);\n }\n });\n\n exports.BooleanTransform = boolean;\n exports.DateTransform = date;\n exports.EmbeddedRecordsMixin = embeddedRecordsMixin;\n exports.NumberTransform = number;\n exports.StringTransform = string;\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\"], function (_exports) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.default = void 0;\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 @extends EmberObject\n */\n var _default = Ember.Object.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 @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 /**\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 @param {Snapshot} snapshot\n @param {Object} [options]\n @return {Object}\n */\n serialize: null,\n\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 @param {Model} typeClass\n @param {Object} hash\n @return {Object}\n */\n normalize: function normalize(typeClass, hash) {\n return hash;\n }\n });\n\n _exports.default = _default;\n});","define(\"@ember-data/serializer/json-api\", [\"exports\", \"@ember/string\", \"ember-inflector\", \"@ember-data/serializer/json\", \"@ember-data/store\"], function (_exports, _string, _emberInflector, _json, _store) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.default = void 0;\n\n /**\n @module @ember-data/serializer\n */\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';\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 @since 1.13.0\n @class JSONAPISerializer\n @extends JSONSerializer\n */\n var JSONAPISerializer = _json.default.extend({\n /**\n @method _normalizeDocumentHelper\n @param {Object} documentHash\n @return {Object}\n @private\n */\n _normalizeDocumentHelper: function _normalizeDocumentHelper(documentHash) {\n if (Ember.typeOf(documentHash.data) === 'object') {\n documentHash.data = this._normalizeResourceHelper(documentHash.data);\n } else if (Array.isArray(documentHash.data)) {\n var ret = new Array(documentHash.data.length);\n\n for (var i = 0; i < documentHash.data.length; i++) {\n var data = documentHash.data[i];\n ret[i] = this._normalizeResourceHelper(data);\n }\n\n documentHash.data = ret;\n }\n\n if (Array.isArray(documentHash.included)) {\n var _ret = new Array();\n\n for (var _i = 0; _i < documentHash.included.length; _i++) {\n var included = documentHash.included[_i];\n\n var normalized = this._normalizeResourceHelper(included);\n\n if (normalized !== null) {\n // can be null when unknown type is encountered\n _ret.push(normalized);\n }\n }\n\n documentHash.included = _ret;\n }\n\n return documentHash;\n },\n\n /**\n @method _normalizeRelationshipDataHelper\n @param {Object} relationshipDataHash\n @return {Object}\n @private\n */\n _normalizeRelationshipDataHelper: function _normalizeRelationshipDataHelper(relationshipDataHash) {\n relationshipDataHash.type = this.modelNameFromPayloadKey(relationshipDataHash.type);\n return relationshipDataHash;\n },\n\n /**\n @method _normalizeResourceHelper\n @param {Object} resourceHash\n @return {Object}\n @private\n */\n _normalizeResourceHelper: function _normalizeResourceHelper(resourceHash) {\n (true && !(!Ember.isNone(resourceHash.type)) && Ember.assert(this.warnMessageForUndefinedType(), !Ember.isNone(resourceHash.type), {\n id: 'ds.serializer.type-is-undefined'\n }));\n var modelName, usedLookup;\n modelName = this.modelNameFromPayloadKey(resourceHash.type);\n usedLookup = 'modelNameFromPayloadKey';\n\n if (!this.store._hasModelFor(modelName)) {\n (true && Ember.warn(this.warnMessageNoModelForType(modelName, resourceHash.type, usedLookup), false, {\n id: 'ds.serializer.model-for-type-missing'\n }));\n return null;\n }\n\n var modelClass = this.store.modelFor(modelName);\n var serializer = this.store.serializerFor(modelName);\n\n var _serializer$normalize = serializer.normalize(modelClass, resourceHash),\n data = _serializer$normalize.data;\n\n return data;\n },\n\n /**\n @method pushPayload\n @param {Store} store\n @param {Object} payload\n */\n pushPayload: function pushPayload(store, payload) {\n var normalizedPayload = this._normalizeDocumentHelper(payload);\n\n store.push(normalizedPayload);\n },\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: function _normalizeResponse(store, primaryModelClass, payload, id, requestType, isSingle) {\n var normalizedPayload = this._normalizeDocumentHelper(payload);\n\n return normalizedPayload;\n },\n normalizeQueryRecordResponse: function normalizeQueryRecordResponse() {\n var normalized = this._super.apply(this, arguments);\n\n (true && !(!Array.isArray(normalized.data)) && Ember.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: function extractAttributes(modelClass, resourceHash) {\n var _this = this;\n\n var attributes = {};\n\n if (resourceHash.attributes) {\n modelClass.eachAttribute(function (key) {\n var attributeKey = _this.keyForAttribute(key, 'deserialize');\n\n if (resourceHash.attributes[attributeKey] !== undefined) {\n attributes[key] = resourceHash.attributes[attributeKey];\n }\n\n if (true\n /* DEBUG */\n ) {\n if (resourceHash.attributes[attributeKey] === undefined && resourceHash.attributes[key] !== undefined) {\n (true && !(false) && Ember.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\n return attributes;\n },\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 @param {Object} relationshipHash\n @return {Object}\n */\n extractRelationship: function extractRelationship(relationshipHash) {\n if (Ember.typeOf(relationshipHash.data) === 'object') {\n relationshipHash.data = this._normalizeRelationshipDataHelper(relationshipHash.data);\n }\n\n if (Array.isArray(relationshipHash.data)) {\n var ret = new Array(relationshipHash.data.length);\n\n for (var i = 0; i < relationshipHash.data.length; i++) {\n var data = relationshipHash.data[i];\n ret[i] = this._normalizeRelationshipDataHelper(data);\n }\n\n relationshipHash.data = ret;\n }\n\n return relationshipHash;\n },\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 @param {Object} modelClass\n @param {Object} resourceHash\n @return {Object}\n */\n extractRelationships: function extractRelationships(modelClass, resourceHash) {\n var _this2 = this;\n\n var relationships = {};\n\n if (resourceHash.relationships) {\n modelClass.eachRelationship(function (key, relationshipMeta) {\n var relationshipKey = _this2.keyForRelationship(key, relationshipMeta.kind, 'deserialize');\n\n if (resourceHash.relationships[relationshipKey] !== undefined) {\n var relationshipHash = resourceHash.relationships[relationshipKey];\n relationships[key] = _this2.extractRelationship(relationshipHash);\n }\n\n if (true\n /* DEBUG */\n ) {\n if (resourceHash.relationships[relationshipKey] === undefined && resourceHash.relationships[key] !== undefined) {\n (true && !(false) && Ember.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\n return relationships;\n },\n\n /**\n @method _extractType\n @param {Model} modelClass\n @param {Object} resourceHash\n @return {String}\n @private\n */\n _extractType: function _extractType(modelClass, resourceHash) {\n return this.modelNameFromPayloadKey(resourceHash.type);\n },\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 @param {String} key\n @return {String} the model's modelName\n */\n // TODO @deprecated Use modelNameFromPayloadType instead\n modelNameFromPayloadKey: function modelNameFromPayloadKey(key) {\n return (0, _emberInflector.singularize)((0, _store.normalizeModelName)(key));\n },\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 @param {String} modelName\n @return {String}\n */\n // TODO @deprecated Use payloadTypeFromModelName instead\n payloadKeyFromModelName: function payloadKeyFromModelName(modelName) {\n return (0, _emberInflector.pluralize)(modelName);\n },\n normalize: function normalize(modelClass, resourceHash) {\n if (resourceHash.attributes) {\n this.normalizeUsingDeclaredMapping(modelClass, resourceHash.attributes);\n }\n\n if (resourceHash.relationships) {\n this.normalizeUsingDeclaredMapping(modelClass, resourceHash.relationships);\n }\n\n var 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: data\n };\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 @param {String} key\n @param {String} method\n @return {String} normalized key\n */\n keyForAttribute: function keyForAttribute(key, method) {\n return (0, _string.dasherize)(key);\n },\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 @param {String} key\n @param {String} typeClass\n @param {String} method\n @return {String} normalized key\n */\n keyForRelationship: function keyForRelationship(key, typeClass, method) {\n return (0, _string.dasherize)(key);\n },\n serialize: function serialize(snapshot, options) {\n var data = this._super.apply(this, arguments);\n\n data.type = this.payloadKeyFromModelName(snapshot.modelName);\n return {\n data: data\n };\n },\n serializeAttribute: function serializeAttribute(snapshot, json, key, attribute) {\n var type = attribute.type;\n\n if (this._canSerialize(key)) {\n json.attributes = json.attributes || {};\n var value = snapshot.attr(key);\n\n if (type) {\n var transform = this.transformFor(type);\n value = transform.serialize(value, attribute.options);\n }\n\n var payloadKey = this._getMappedKey(key, snapshot.type);\n\n if (payloadKey === key) {\n payloadKey = this.keyForAttribute(key, 'serialize');\n }\n\n json.attributes[payloadKey] = value;\n }\n },\n serializeBelongsTo: function serializeBelongsTo(snapshot, json, relationship) {\n var key = relationship.key;\n\n if (this._canSerialize(key)) {\n var belongsTo = snapshot.belongsTo(key);\n var belongsToIsNotNew;\n\n if (false\n /* CUSTOM_MODEL_CLASS */\n ) {\n belongsToIsNotNew = belongsTo && !belongsTo.isNew;\n } else {\n belongsToIsNotNew = belongsTo && belongsTo.record && !belongsTo.record.get('isNew');\n }\n\n if (belongsTo === null || belongsToIsNotNew) {\n json.relationships = json.relationships || {};\n\n var payloadKey = this._getMappedKey(key, snapshot.type);\n\n if (payloadKey === key) {\n payloadKey = this.keyForRelationship(key, 'belongsTo', 'serialize');\n }\n\n var data = null;\n\n if (belongsTo) {\n var payloadType = this.payloadKeyFromModelName(belongsTo.modelName);\n data = {\n type: payloadType,\n id: belongsTo.id\n };\n }\n\n json.relationships[payloadKey] = {\n data: data\n };\n }\n }\n },\n serializeHasMany: function serializeHasMany(snapshot, json, relationship) {\n var key = relationship.key;\n\n if (this.shouldSerializeHasMany(snapshot, key, relationship)) {\n var hasMany = snapshot.hasMany(key);\n\n if (hasMany !== undefined) {\n json.relationships = json.relationships || {};\n\n var payloadKey = this._getMappedKey(key, snapshot.type);\n\n if (payloadKey === key && this.keyForRelationship) {\n payloadKey = this.keyForRelationship(key, 'hasMany', 'serialize');\n } // only serialize has many relationships that are not new\n\n\n var nonNewHasMany = hasMany.filter(function (item) {\n return item.record && !item.record.get('isNew');\n });\n var data = new Array(nonNewHasMany.length);\n\n for (var i = 0; i < nonNewHasMany.length; i++) {\n var item = hasMany[i];\n var payloadType = this.payloadKeyFromModelName(item.modelName);\n data[i] = {\n type: payloadType,\n id: item.id\n };\n }\n\n json.relationships[payloadKey] = {\n data: data\n };\n }\n }\n }\n });\n\n if (true\n /* DEBUG */\n ) {\n JSONAPISerializer.reopen({\n init: function init() {\n this._super.apply(this, arguments);\n\n (true && !(!this.isEmbeddedRecordsMixin || this.isEmbeddedRecordsMixinCompatible === true) && Ember.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 var constructor = this.constructor;\n (true && Ember.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: function warnMessageForUndefinedType() {\n return 'Encountered a resource object with an undefined type (resolved resource using ' + this.constructor.toString() + ')';\n },\n warnMessageNoModelForType: function 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\n var _default = JSONAPISerializer;\n _exports.default = _default;\n});","define(\"@ember-data/serializer/json\", [\"exports\", \"@ember-data/serializer\", \"@ember-data/store\", \"@ember-data/store/-private\", \"@ember-data/serializer/-private\"], function (_exports, _serializer, _store, _private, _private2) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.default = void 0;\n\n /**\n @module @ember-data/serializer\n */\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 - `normalizeResponse` - entry method to the serializer.\n - `normalizeCreateRecordResponse` - a `normalizeResponse` for a specific operation is called.\n - `normalizeSingleResponse`|`normalizeArrayResponse` - for methods like `createRecord` we expect\n a single record back, while for methods like `findAll` we expect multiple records back.\n - `normalize` - `normalizeArray` 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 - `extractId` | `extractAttributes` | `extractRelationships` - `normalize` delegates to these methods to\n turn the record payload into the JSON API format.\n \n @class JSONSerializer\n @extends Serializer\n */\n var 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 @default 'id'\n */\n primaryKey: 'id',\n\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 @type {Object}\n */\n mergedProperties: ['attrs'],\n\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: function applyTransforms(typeClass, data) {\n var _this = this;\n\n var attributes = Ember.get(typeClass, 'attributes');\n typeClass.eachTransformedAttribute(function (key, typeClass) {\n if (data[key] === undefined) {\n return;\n }\n\n var transform = _this.transformFor(typeClass);\n\n var transformMeta = attributes.get(key);\n data[key] = transform.deserialize(data[key], transformMeta.options);\n });\n return data;\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 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 this._super(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 @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: function normalizeResponse(store, primaryModelClass, payload, id, requestType) {\n switch (requestType) {\n case 'findRecord':\n return this.normalizeFindRecordResponse.apply(this, arguments);\n\n case 'queryRecord':\n return this.normalizeQueryRecordResponse.apply(this, arguments);\n\n case 'findAll':\n return this.normalizeFindAllResponse.apply(this, arguments);\n\n case 'findBelongsTo':\n return this.normalizeFindBelongsToResponse.apply(this, arguments);\n\n case 'findHasMany':\n return this.normalizeFindHasManyResponse.apply(this, arguments);\n\n case 'findMany':\n return this.normalizeFindManyResponse.apply(this, arguments);\n\n case 'query':\n return this.normalizeQueryResponse.apply(this, arguments);\n\n case 'createRecord':\n return this.normalizeCreateRecordResponse.apply(this, arguments);\n\n case 'deleteRecord':\n return this.normalizeDeleteRecordResponse.apply(this, arguments);\n\n case 'updateRecord':\n return this.normalizeUpdateRecordResponse.apply(this, arguments);\n }\n },\n\n /**\n @since 1.13.0\n @method normalizeFindRecordResponse\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: function normalizeFindRecordResponse(store, primaryModelClass, payload, id, requestType) {\n return this.normalizeSingleResponse.apply(this, arguments);\n },\n\n /**\n @since 1.13.0\n @method normalizeQueryRecordResponse\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: function normalizeQueryRecordResponse(store, primaryModelClass, payload, id, requestType) {\n return this.normalizeSingleResponse.apply(this, arguments);\n },\n\n /**\n @since 1.13.0\n @method normalizeFindAllResponse\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: function normalizeFindAllResponse(store, primaryModelClass, payload, id, requestType) {\n return this.normalizeArrayResponse.apply(this, arguments);\n },\n\n /**\n @since 1.13.0\n @method normalizeFindBelongsToResponse\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: function normalizeFindBelongsToResponse(store, primaryModelClass, payload, id, requestType) {\n return this.normalizeSingleResponse.apply(this, arguments);\n },\n\n /**\n @since 1.13.0\n @method normalizeFindHasManyResponse\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: function normalizeFindHasManyResponse(store, primaryModelClass, payload, id, requestType) {\n return this.normalizeArrayResponse.apply(this, arguments);\n },\n\n /**\n @since 1.13.0\n @method normalizeFindManyResponse\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: function normalizeFindManyResponse(store, primaryModelClass, payload, id, requestType) {\n return this.normalizeArrayResponse.apply(this, arguments);\n },\n\n /**\n @since 1.13.0\n @method normalizeQueryResponse\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: function normalizeQueryResponse(store, primaryModelClass, payload, id, requestType) {\n return this.normalizeArrayResponse.apply(this, arguments);\n },\n\n /**\n @since 1.13.0\n @method normalizeCreateRecordResponse\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: function normalizeCreateRecordResponse(store, primaryModelClass, payload, id, requestType) {\n return this.normalizeSaveResponse.apply(this, arguments);\n },\n\n /**\n @since 1.13.0\n @method normalizeDeleteRecordResponse\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: function normalizeDeleteRecordResponse(store, primaryModelClass, payload, id, requestType) {\n return this.normalizeSaveResponse.apply(this, arguments);\n },\n\n /**\n @since 1.13.0\n @method normalizeUpdateRecordResponse\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: function normalizeUpdateRecordResponse(store, primaryModelClass, payload, id, requestType) {\n return this.normalizeSaveResponse.apply(this, arguments);\n },\n\n /**\n @since 1.13.0\n @method normalizeSaveResponse\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: function normalizeSaveResponse(store, primaryModelClass, payload, id, requestType) {\n return this.normalizeSingleResponse.apply(this, arguments);\n },\n\n /**\n @since 1.13.0\n @method normalizeSingleResponse\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: function normalizeSingleResponse(store, primaryModelClass, payload, id, requestType) {\n return this._normalizeResponse(store, primaryModelClass, payload, id, requestType, true);\n },\n\n /**\n @since 1.13.0\n @method normalizeArrayResponse\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: function normalizeArrayResponse(store, primaryModelClass, payload, id, requestType) {\n return this._normalizeResponse(store, primaryModelClass, payload, id, requestType, false);\n },\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: function _normalizeResponse(store, primaryModelClass, payload, id, requestType, isSingle) {\n var documentHash = {\n data: null,\n included: []\n };\n var meta = this.extractMeta(store, primaryModelClass, payload);\n\n if (meta) {\n (true && !(Ember.typeOf(meta) === 'object') && Ember.assert('The `meta` returned from `extractMeta` has to be an object, not \"' + Ember.typeOf(meta) + '\".', Ember.typeOf(meta) === 'object'));\n documentHash.meta = meta;\n }\n\n if (isSingle) {\n var _this$normalize = this.normalize(primaryModelClass, payload),\n data = _this$normalize.data,\n included = _this$normalize.included;\n\n documentHash.data = data;\n\n if (included) {\n documentHash.included = included;\n }\n } else {\n var ret = new Array(payload.length);\n\n for (var i = 0, l = payload.length; i < l; i++) {\n var item = payload[i];\n\n var _this$normalize2 = this.normalize(primaryModelClass, item),\n _data = _this$normalize2.data,\n _included = _this$normalize2.included;\n\n if (_included) {\n var _documentHash$include;\n\n (_documentHash$include = documentHash.included).push.apply(_documentHash$include, _included);\n }\n\n ret[i] = _data;\n }\n\n documentHash.data = ret;\n }\n\n return documentHash;\n },\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 this._super.apply(this, arguments);\n }\n }\n ```\n @method normalize\n @param {Model} typeClass\n @param {Object} hash\n @return {Object}\n */\n normalize: function normalize(modelClass, resourceHash) {\n var data = null;\n\n if (resourceHash) {\n this.normalizeUsingDeclaredMapping(modelClass, resourceHash);\n\n if (Ember.typeOf(resourceHash.links) === 'object') {\n this.normalizeUsingDeclaredMapping(modelClass, resourceHash.links);\n }\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\n return {\n data: data\n };\n },\n\n /**\n Returns the resource's ID.\n @method extractId\n @param {Object} modelClass\n @param {Object} resourceHash\n @return {String}\n */\n extractId: function extractId(modelClass, resourceHash) {\n var primaryKey = Ember.get(this, 'primaryKey');\n var id = resourceHash[primaryKey];\n return (0, _private.coerceId)(id);\n },\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 @param {Object} modelClass\n @param {Object} resourceHash\n @return {Object}\n */\n extractAttributes: function extractAttributes(modelClass, resourceHash) {\n var _this2 = this;\n\n var attributeKey;\n var attributes = {};\n modelClass.eachAttribute(function (key) {\n attributeKey = _this2.keyForAttribute(key, 'deserialize');\n\n if (resourceHash[attributeKey] !== undefined) {\n attributes[key] = resourceHash[attributeKey];\n }\n });\n return attributes;\n },\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 @param {Object} relationshipModelName\n @param {Object} relationshipHash\n @return {Object}\n */\n extractRelationship: function extractRelationship(relationshipModelName, relationshipHash) {\n if (Ember.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\n\n if (Ember.typeOf(relationshipHash) === 'object') {\n if (relationshipHash.id) {\n relationshipHash.id = (0, _private.coerceId)(relationshipHash.id);\n }\n\n var modelClass = this.store.modelFor(relationshipModelName);\n\n if (relationshipHash.type && !(0, _private2.modelHasAttributeOrRelationshipNamedType)(modelClass)) {\n relationshipHash.type = this.modelNameFromPayloadKey(relationshipHash.type);\n }\n\n return relationshipHash;\n }\n\n return {\n id: (0, _private.coerceId)(relationshipHash),\n type: relationshipModelName\n };\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 @param {Object} relationshipModelName\n @param {Object} relationshipHash\n @param {Object} relationshipOptions\n @return {Object}\n */\n extractPolymorphicRelationship: function extractPolymorphicRelationship(relationshipModelName, relationshipHash, relationshipOptions) {\n return this.extractRelationship(relationshipModelName, relationshipHash);\n },\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 @param {Object} modelClass\n @param {Object} resourceHash\n @return {Object}\n */\n extractRelationships: function extractRelationships(modelClass, resourceHash) {\n var _this3 = this;\n\n var relationships = {};\n modelClass.eachRelationship(function (key, relationshipMeta) {\n var relationship = null;\n\n var relationshipKey = _this3.keyForRelationship(key, relationshipMeta.kind, 'deserialize');\n\n if (resourceHash[relationshipKey] !== undefined) {\n var data = null;\n var relationshipHash = resourceHash[relationshipKey];\n\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 = _this3.extractPolymorphicRelationship(relationshipMeta.type, relationshipHash, {\n key: key,\n resourceHash: resourceHash,\n relationshipMeta: relationshipMeta\n });\n } else {\n data = _this3.extractRelationship(relationshipMeta.type, relationshipHash);\n }\n } else if (relationshipMeta.kind === 'hasMany') {\n if (!Ember.isNone(relationshipHash)) {\n data = new Array(relationshipHash.length);\n\n if (relationshipMeta.options.polymorphic) {\n for (var i = 0, l = relationshipHash.length; i < l; i++) {\n var item = relationshipHash[i];\n data[i] = _this3.extractPolymorphicRelationship(relationshipMeta.type, item, {\n key: key,\n resourceHash: resourceHash,\n relationshipMeta: relationshipMeta\n });\n }\n } else {\n for (var _i = 0, _l = relationshipHash.length; _i < _l; _i++) {\n var _item = relationshipHash[_i];\n data[_i] = _this3.extractRelationship(relationshipMeta.type, _item);\n }\n }\n }\n }\n\n relationship = {\n data: data\n };\n }\n\n var linkKey = _this3.keyForLink(key, relationshipMeta.kind);\n\n if (resourceHash.links && resourceHash.links[linkKey] !== undefined) {\n var related = resourceHash.links[linkKey];\n relationship = relationship || {};\n relationship.links = {\n related: related\n };\n }\n\n if (relationship) {\n relationships[key] = relationship;\n }\n });\n return relationships;\n },\n\n /**\n @method modelNameFromPayloadKey\n @param {String} key\n @return {String} the model's modelName\n */\n // TODO @deprecated Use modelNameFromPayloadType instead\n modelNameFromPayloadKey: function modelNameFromPayloadKey(key) {\n return (0, _store.normalizeModelName)(key);\n },\n\n /**\n @method normalizeRelationships\n @private\n */\n normalizeRelationships: function normalizeRelationships(typeClass, hash) {\n var _this4 = this;\n\n var payloadKey;\n\n if (this.keyForRelationship) {\n typeClass.eachRelationship(function (key, relationship) {\n payloadKey = _this4.keyForRelationship(key, relationship.kind, 'deserialize');\n\n if (key === payloadKey) {\n return;\n }\n\n if (hash[payloadKey] === undefined) {\n return;\n }\n\n hash[key] = hash[payloadKey];\n delete hash[payloadKey];\n });\n }\n },\n\n /**\n @method normalizeUsingDeclaredMapping\n @private\n */\n normalizeUsingDeclaredMapping: function normalizeUsingDeclaredMapping(modelClass, hash) {\n var attrs = Ember.get(this, 'attrs');\n var normalizedKey;\n var payloadKey;\n\n if (attrs) {\n for (var key in attrs) {\n normalizedKey = payloadKey = this._getMappedKey(key, modelClass);\n\n if (hash[payloadKey] === undefined) {\n continue;\n }\n\n if (Ember.get(modelClass, 'attributes').has(key)) {\n normalizedKey = this.keyForAttribute(key);\n }\n\n if (Ember.get(modelClass, 'relationshipsByName').has(key)) {\n normalizedKey = this.keyForRelationship(key);\n }\n\n if (payloadKey !== normalizedKey) {\n hash[normalizedKey] = hash[payloadKey];\n delete hash[payloadKey];\n }\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: function _getMappedKey(key, modelClass) {\n (true && Ember.warn('There is no attribute or relationship with the name `' + key + '` on `' + modelClass.modelName + '`. Check your serializers attrs hash.', Ember.get(modelClass, 'attributes').has(key) || Ember.get(modelClass, 'relationshipsByName').has(key), {\n id: 'ds.serializer.no-mapped-attrs-key'\n }));\n var attrs = Ember.get(this, 'attrs');\n var mappedKey;\n\n if (attrs && attrs[key]) {\n mappedKey = attrs[key]; //We need to account for both the { title: 'post_title' } and\n //{ title: { key: 'post_title' }} forms\n\n if (mappedKey.key) {\n mappedKey = mappedKey.key;\n }\n\n if (typeof mappedKey === 'string') {\n key = mappedKey;\n }\n }\n\n return key;\n },\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: function _canSerialize(key) {\n var attrs = Ember.get(this, 'attrs');\n return !attrs || !attrs[key] || attrs[key].serialize !== false;\n },\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: function _mustSerialize(key) {\n var attrs = Ember.get(this, 'attrs');\n return attrs && attrs[key] && attrs[key].serialize === true;\n },\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 @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: function shouldSerializeHasMany(snapshot, key, relationship) {\n var relationshipType = snapshot.type.determineRelationshipType(relationship, this.store);\n\n if (this._mustSerialize(key)) {\n return true;\n }\n\n return this._canSerialize(key) && (relationshipType === 'manyToNone' || relationshipType === 'manyToMany');\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 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 PostSerializer extends JSONSerializer {\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 ```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 first and make the tweaks on the returned\n 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 = this._super(...arguments);\n json.subject = json.title;\n delete json.title;\n return json;\n }\n }\n ```\n @method serialize\n @param {Snapshot} snapshot\n @param {Object} options\n @return {Object} json\n */\n serialize: function serialize(snapshot, options) {\n var _this5 = this;\n\n var json = {};\n\n if (options && options.includeId) {\n var id = snapshot.id;\n\n if (id) {\n json[Ember.get(this, 'primaryKey')] = id;\n }\n }\n\n snapshot.eachAttribute(function (key, attribute) {\n _this5.serializeAttribute(snapshot, json, key, attribute);\n });\n snapshot.eachRelationship(function (key, relationship) {\n if (relationship.kind === 'belongsTo') {\n _this5.serializeBelongsTo(snapshot, json, relationship);\n } else if (relationship.kind === 'hasMany') {\n _this5.serializeHasMany(snapshot, json, relationship);\n }\n });\n return json;\n },\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 @param {Object} hash\n @param {Model} typeClass\n @param {Snapshot} snapshot\n @param {Object} options\n */\n serializeIntoHash: function serializeIntoHash(hash, typeClass, snapshot, options) {\n Ember.assign(hash, this.serialize(snapshot, options));\n },\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 this._super(snapshot, json.attributes, key, attributes);\n }\n }\n ```\n @method serializeAttribute\n @param {Snapshot} snapshot\n @param {Object} json\n @param {String} key\n @param {Object} attribute\n */\n serializeAttribute: function serializeAttribute(snapshot, json, key, attribute) {\n if (this._canSerialize(key)) {\n var type = attribute.type;\n var value = snapshot.attr(key);\n\n if (type) {\n var transform = this.transformFor(type);\n value = transform.serialize(value, attribute.options);\n } // if provided, use the mapping provided by `attrs` in\n // the serializer\n\n\n var payloadKey = this._getMappedKey(key, snapshot.type);\n\n if (payloadKey === key && this.keyForAttribute) {\n payloadKey = this.keyForAttribute(key, 'serialize');\n }\n\n json[payloadKey] = value;\n }\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 @param {Snapshot} snapshot\n @param {Object} json\n @param {Object} relationship\n */\n serializeBelongsTo: function serializeBelongsTo(snapshot, json, relationship) {\n var key = relationship.key;\n\n if (this._canSerialize(key)) {\n var belongsToId = snapshot.belongsTo(key, {\n id: true\n }); // if provided, use the mapping provided by `attrs` in\n // the serializer\n\n var payloadKey = this._getMappedKey(key, snapshot.type);\n\n if (payloadKey === key && this.keyForRelationship) {\n payloadKey = this.keyForRelationship(key, 'belongsTo', 'serialize');\n } //Need to check whether the id is there for new&async records\n\n\n if (Ember.isNone(belongsToId)) {\n json[payloadKey] = null;\n } else {\n json[payloadKey] = belongsToId;\n }\n\n if (relationship.options.polymorphic) {\n this.serializePolymorphicType(snapshot, json, relationship);\n }\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 this._super(...arguments);\n }\n }\n }\n ```\n @method serializeHasMany\n @param {Snapshot} snapshot\n @param {Object} json\n @param {Object} relationship\n */\n serializeHasMany: function serializeHasMany(snapshot, json, relationship) {\n var key = relationship.key;\n\n if (this.shouldSerializeHasMany(snapshot, key, relationship)) {\n var hasMany = snapshot.hasMany(key, {\n ids: true\n });\n\n if (hasMany !== undefined) {\n // if provided, use the mapping provided by `attrs` in\n // the serializer\n var payloadKey = this._getMappedKey(key, snapshot.type);\n\n if (payloadKey === key && this.keyForRelationship) {\n payloadKey = this.keyForRelationship(key, 'hasMany', 'serialize');\n }\n\n json[payloadKey] = hasMany; // TODO support for polymorphic manyToNone and manyToMany relationships\n }\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 @param {Snapshot} snapshot\n @param {Object} json\n @param {Object} relationship\n */\n serializePolymorphicType: function serializePolymorphicType() {},\n\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 @param {Store} store\n @param {Model} modelClass\n @param {Object} payload\n */\n extractMeta: function extractMeta(store, modelClass, payload) {\n if (payload && payload['meta'] !== undefined) {\n var meta = payload.meta;\n delete payload.meta;\n return meta;\n }\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 @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: function extractErrors(store, typeClass, payload, id) {\n var _this6 = this;\n\n if (payload && typeof payload === 'object' && payload.errors) {\n payload = (0, _private.errorsArrayToHash)(payload.errors);\n this.normalizeUsingDeclaredMapping(typeClass, payload);\n typeClass.eachAttribute(function (name) {\n var key = _this6.keyForAttribute(name, 'deserialize');\n\n if (key !== name && payload[key] !== undefined) {\n payload[name] = payload[key];\n delete payload[key];\n }\n });\n typeClass.eachRelationship(function (name) {\n var key = _this6.keyForRelationship(name, 'deserialize');\n\n if (key !== name && payload[key] !== undefined) {\n payload[name] = payload[key];\n delete payload[key];\n }\n });\n }\n\n return payload;\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 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 @param {String} key\n @param {String} method\n @return {String} normalized key\n */\n keyForAttribute: function keyForAttribute(key, method) {\n return key;\n },\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 @param {String} key\n @param {String} typeClass\n @param {String} method\n @return {String} normalized key\n */\n keyForRelationship: function keyForRelationship(key, typeClass, method) {\n return key;\n },\n\n /**\n `keyForLink` can be used to define a custom key when deserializing link\n properties.\n @method keyForLink\n @param {String} key\n @param {String} kind `belongsTo` or `hasMany`\n @return {String} normalized key\n */\n keyForLink: function 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: function transformFor(attributeType, skipAssertion) {\n var transform = Ember.getOwner(this).lookup('transform:' + attributeType);\n (true && !(skipAssertion || !!transform) && Ember.assert(\"Unable to find the transform for `attr('\" + attributeType + \"')`\", skipAssertion || !!transform));\n return transform;\n }\n });\n\n var _default = JSONSerializer;\n _exports.default = _default;\n});","define(\"@ember-data/serializer/rest\", [\"exports\", \"@ember/string\", \"ember-inflector\", \"@ember-data/serializer/json\", \"@ember-data/store\", \"@ember-data/store/-private\", \"@ember-data/serializer/-private\"], function (_exports, _string, _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 get() {\n return _private2.EmbeddedRecordsMixin;\n }\n });\n _exports.default = void 0;\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 @extends JSONSerializer\n */\n var 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 @param {String} key\n @param {String} typeClass\n @param {String} method\n @return {String} normalized key\n */\n keyForPolymorphicType: function keyForPolymorphicType(key, typeClass, method) {\n var relationshipKey = this.keyForRelationship(key);\n return relationshipKey + \"Type\";\n },\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 @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: function _normalizeArray(store, modelName, arrayHash, prop) {\n var _this = this;\n\n var documentHash = {\n data: [],\n included: []\n };\n var modelClass = store.modelFor(modelName);\n var serializer = store.serializerFor(modelName);\n Ember.makeArray(arrayHash).forEach(function (hash) {\n var _this$_normalizePolym = _this._normalizePolymorphicRecord(store, hash, prop, modelClass, serializer),\n data = _this$_normalizePolym.data,\n included = _this$_normalizePolym.included;\n\n documentHash.data.push(data);\n\n if (included) {\n var _documentHash$include;\n\n (_documentHash$include = documentHash.included).push.apply(_documentHash$include, included);\n }\n });\n return documentHash;\n },\n _normalizePolymorphicRecord: function _normalizePolymorphicRecord(store, hash, prop, primaryModelClass, primarySerializer) {\n var serializer = primarySerializer;\n var modelClass = primaryModelClass;\n var primaryHasTypeAttribute = (0, _private2.modelHasAttributeOrRelationshipNamedType)(primaryModelClass);\n\n if (!primaryHasTypeAttribute && hash.type) {\n // Support polymorphic records in async relationships\n var modelName = this.modelNameFromPayloadKey(hash.type);\n\n if (store._hasModelFor(modelName)) {\n serializer = store.serializerFor(modelName);\n modelClass = store.modelFor(modelName);\n }\n }\n\n return serializer.normalize(modelClass, hash, prop);\n },\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: function _normalizeResponse(store, primaryModelClass, payload, id, requestType, isSingle) {\n var documentHash = {\n data: null,\n included: []\n };\n var meta = this.extractMeta(store, primaryModelClass, payload);\n\n if (meta) {\n (true && !(Ember.typeOf(meta) === 'object') && Ember.assert('The `meta` returned from `extractMeta` has to be an object, not \"' + Ember.typeOf(meta) + '\".', Ember.typeOf(meta) === 'object'));\n documentHash.meta = meta;\n }\n\n var keys = Object.keys(payload);\n\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 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\n if (prop.charAt(0) === '_') {\n forcedSecondary = true;\n modelName = prop.substr(1);\n }\n\n var typeName = this.modelNameFromPayloadKey(modelName);\n\n if (!store._hasModelFor(typeName)) {\n (true && Ember.warn(this.warnMessageNoModelForKey(modelName, typeName), false, {\n id: 'ds.serializer.model-for-key-missing'\n }));\n continue;\n }\n\n var isPrimary = !forcedSecondary && this.isPrimaryType(store, typeName, primaryModelClass);\n var value = payload[prop];\n\n if (value === null) {\n continue;\n }\n\n if (true\n /* DEBUG */\n ) {\n var isQueryRecordAnArray = requestType === 'queryRecord' && isPrimary && Array.isArray(value);\n var message = 'The adapter returned an array for the primary data of a `queryRecord` response. This is deprecated as `queryRecord` should return a single record.';\n (true && !(!isQueryRecordAnArray) && Ember.deprecate(message, !isQueryRecordAnArray, {\n id: 'ds.serializer.rest.queryRecord-array-response',\n until: '3.0',\n url: 'https://deprecations.emberjs.com/ember-data/v2.x/#toc_store-queryrecord-array-response-with-restserializer'\n }));\n }\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\n\n if (isPrimary && !Array.isArray(value)) {\n var _this$_normalizePolym2 = this._normalizePolymorphicRecord(store, value, prop, primaryModelClass, this),\n _data = _this$_normalizePolym2.data,\n _included = _this$_normalizePolym2.included;\n\n documentHash.data = _data;\n\n if (_included) {\n var _documentHash$include2;\n\n (_documentHash$include2 = documentHash.included).push.apply(_documentHash$include2, _included);\n }\n\n continue;\n }\n\n var _this$_normalizeArray = this._normalizeArray(store, typeName, value, prop),\n data = _this$_normalizeArray.data,\n included = _this$_normalizeArray.included;\n\n if (included) {\n var _documentHash$include3;\n\n (_documentHash$include3 = documentHash.included).push.apply(_documentHash$include3, included);\n }\n\n if (isSingle) {\n data.forEach(function (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 var isUpdatedRecord = isPrimary && (0, _private.coerceId)(resource.id) === id;\n var isFirstCreatedRecord = isPrimary && !id && !documentHash.data;\n\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 var _documentHash$include4;\n\n (_documentHash$include4 = documentHash.included).push.apply(_documentHash$include4, data);\n }\n }\n }\n }\n\n return documentHash;\n },\n isPrimaryType: function isPrimaryType(store, modelName, primaryModelClass) {\n return (0, _store.normalizeModelName)(modelName) === primaryModelClass.modelName;\n },\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 @param {Store} store\n @param {Object} payload\n */\n pushPayload: function pushPayload(store, payload) {\n var documentHash = {\n data: [],\n included: []\n };\n\n for (var prop in payload) {\n var modelName = this.modelNameFromPayloadKey(prop);\n\n if (!store._hasModelFor(modelName)) {\n (true && Ember.warn(this.warnMessageNoModelForKey(prop, modelName), false, {\n id: 'ds.serializer.model-for-key-missing'\n }));\n continue;\n }\n\n var type = store.modelFor(modelName);\n var typeSerializer = store.serializerFor(type.modelName);\n Ember.makeArray(payload[prop]).forEach(function (hash) {\n var _typeSerializer$norma = typeSerializer.normalize(type, hash, prop),\n data = _typeSerializer$norma.data,\n included = _typeSerializer$norma.included;\n\n documentHash.data.push(data);\n\n if (included) {\n var _documentHash$include5;\n\n (_documentHash$include5 = documentHash.included).push.apply(_documentHash$include5, included);\n }\n });\n }\n\n store.push(documentHash);\n },\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 @param {String} key\n @return {String} the model's modelName\n */\n modelNameFromPayloadKey: function 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 @param {Snapshot} snapshot\n @param {Object} options\n @return {Object} json\n */\n serialize: function serialize(snapshot, options) {\n return this._super.apply(this, arguments);\n },\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 @param {Object} hash\n @param {Model} typeClass\n @param {Snapshot} snapshot\n @param {Object} options\n */\n serializeIntoHash: function serializeIntoHash(hash, typeClass, snapshot, options) {\n var normalizedRootKey = this.payloadKeyFromModelName(typeClass.modelName);\n hash[normalizedRootKey] = this.serialize(snapshot, options);\n },\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 @param {String} modelName\n @return {String}\n */\n payloadKeyFromModelName: function payloadKeyFromModelName(modelName) {\n return (0, _string.camelize)(modelName);\n },\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 @param {Snapshot} snapshot\n @param {Object} json\n @param {Object} relationship\n */\n serializePolymorphicType: function serializePolymorphicType(snapshot, json, relationship) {\n var key = relationship.key;\n var typeKey = this.keyForPolymorphicType(key, relationship.type, 'serialize');\n var belongsTo = snapshot.belongsTo(key);\n\n if (Ember.isNone(belongsTo)) {\n json[typeKey] = null;\n } else {\n json[typeKey] = (0, _string.camelize)(belongsTo.modelName);\n }\n },\n\n /**\n You can use this method to customize how a polymorphic relationship should\n be extracted.\n @method extractPolymorphicRelationship\n @param {Object} relationshipType\n @param {Object} relationshipHash\n @param {Object} relationshipOptions\n @return {Object}\n */\n extractPolymorphicRelationship: function extractPolymorphicRelationship(relationshipType, relationshipHash, relationshipOptions) {\n var key = relationshipOptions.key,\n resourceHash = relationshipOptions.resourceHash,\n relationshipMeta = relationshipOptions.relationshipMeta; // 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\n var isPolymorphic = relationshipMeta.options.polymorphic;\n var typeProperty = this.keyForPolymorphicType(key, relationshipType, 'deserialize');\n\n if (isPolymorphic && resourceHash[typeProperty] !== undefined && typeof relationshipHash !== 'object') {\n var type = this.modelNameFromPayloadKey(resourceHash[typeProperty]);\n return {\n id: relationshipHash,\n type: type\n };\n }\n\n return this._super.apply(this, arguments);\n }\n });\n\n if (true\n /* DEBUG */\n ) {\n RESTSerializer.reopen({\n warnMessageNoModelForKey: function 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\n var _default = RESTSerializer;\n _exports.default = _default;\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\n /**\n @module @ember-data/serializer\n */\n var _default = _private.Transform;\n _exports.default = _default;\n});","define(\"@ember-data/store/-debug/index\", [\"exports\"], function (_exports) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.assertPolymorphicType = void 0;\n\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 @method assertPolymorphicType\n @param {InternalModel} internalModel\n @param {RelationshipMeta} relationshipMeta retrieved via\n `record.relationshipFor(key)`\n @param {InternalModel} addedRecord record which\n should be added/set for the relationship\n */\n var assertPolymorphicType;\n _exports.assertPolymorphicType = assertPolymorphicType;\n\n if (true\n /* DEBUG */\n ) {\n var checkPolymorphic = function checkPolymorphic(modelClass, addedModelClass) {\n if (modelClass.__isMixin) {\n return modelClass.__mixin.detect(addedModelClass.PrototypeMixin) || // handle native class extension e.g. `class Post extends Model.extend(Commentable) {}`\n modelClass.__mixin.detect(Object.getPrototypeOf(addedModelClass).PrototypeMixin);\n }\n\n return addedModelClass.prototype instanceof modelClass || modelClass.detect(addedModelClass);\n };\n\n _exports.assertPolymorphicType = assertPolymorphicType = function assertPolymorphicType(parentInternalModel, relationshipMeta, addedInternalModel, store) {\n var addedModelName = addedInternalModel.modelName;\n var parentModelName = parentInternalModel.modelName;\n var key = relationshipMeta.key;\n var relationshipModelName = relationshipMeta.type;\n var relationshipClass = store.modelFor(relationshipModelName);\n var addedClass = store.modelFor(addedInternalModel.modelName);\n var 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 (true && !(checkPolymorphic(relationshipClass, addedClass)) && Ember.assert(assertionMessage, checkPolymorphic(relationshipClass, addedClass)));\n };\n }\n});","define('@ember-data/store/-private', ['exports', 'require', '@ember/string', '@ember-data/store/-debug', 'ember-inflector'], function (exports, require$1, string, Debug, emberInflector) { 'use strict';\n\n require$1 = require$1 && Object.prototype.hasOwnProperty.call(require$1, 'default') ? require$1['default'] : require$1;\n\n /**\n @module @ember-data/store\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 function coerceId(id) {\n if (id === null || id === undefined || id === '') {\n return null;\n }\n\n if (typeof id === 'string') {\n return id;\n }\n\n if (typeof id === 'symbol') {\n return id.toString();\n }\n\n return '' + id;\n }\n\n function ensureStringId(id) {\n var normalized = null;\n\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\n if (normalized === null) {\n throw new Error(\"Expected id to be a string or number, received \" + String(id));\n }\n\n return normalized;\n }\n\n /**\n @module @ember-data/store\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.\n\n @function normalizeModelName\n @for @ember-data/store\n @param {String} modelName\n @return {String} normalizedModelName\n */\n\n function normalizeModelName(modelName) {\n return string.dasherize(modelName);\n }\n\n /**\n @module @ember-data/store\n */\n\n /**\n * This symbol provides a Symbol replacement for browsers that do not have it\n * (eg. IE 11).\n *\n * The replacement is different from the native Symbol in some ways. It is a\n * function that produces an output:\n * - iterable;\n * - that is a string, not a symbol.\n *\n * @internal\n */\n var symbol = typeof Symbol !== 'undefined' ? Symbol : function (key) {\n return \"__\" + key + Math.floor(Math.random() * Date.now()) + \"__\";\n };\n function addSymbol(obj, symbol, value) {\n if (typeof symbol === 'string') {\n Object.defineProperty(obj, symbol, {\n value: value,\n configurable: false,\n enumerable: false,\n writable: false\n });\n } else {\n // Typescript doesn't allow Symbol as an index type\n obj[symbol] = value;\n }\n }\n\n /**\n @module @ember-data/store\n */\n\n var DEBUG_CLIENT_ORIGINATED = symbol('record-originated-on-client');\n var DEBUG_IDENTIFIER_BUCKET = symbol('identifier-bucket');\n\n function isNonEmptyString(str) {\n return typeof str === 'string' && str.length > 0;\n }\n\n /**\n @module @ember-data/store\n */\n var IDENTIFIERS = new WeakMap();\n function isStableIdentifier(identifier) {\n return IDENTIFIERS.has(identifier);\n }\n function markStableIdentifier(identifier) {\n IDENTIFIERS.set(identifier, 'is-identifier');\n }\n function unmarkStableIdentifier(identifier) {\n IDENTIFIERS.delete(identifier);\n }\n\n /**\n @module @ember-data/store\n */\n // support IE11\n var CRYPTO = function () {\n var hasWindow = typeof window !== 'undefined';\n var isFastBoot = typeof FastBoot !== 'undefined';\n\n if (isFastBoot) {\n return {\n getRandomValues: function 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 if (hasWindow && typeof window.msCrypto !== 'undefined' && typeof window.msCrypto.getRandomValues === 'function') {\n return window.msCrypto;\n } else {\n throw new Error('ember-data: Cannot find a valid way to generate local identifiers');\n }\n }(); // we might be able to optimize this by requesting more bytes than we need at a time\n\n\n function rng() {\n // WHATWG crypto RNG - http://wiki.whatwg.org/wiki/Crypto\n var rnds8 = new Uint8Array(16);\n return CRYPTO.getRandomValues(rnds8);\n }\n /**\n * Convert array of 16 byte values to UUID string format of the form:\n * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX\n */\n\n\n var byteToHex = [];\n\n for (var i = 0; i < 256; ++i) {\n byteToHex[i] = (i + 0x100).toString(16).substr(1);\n }\n\n function bytesToUuid(buf) {\n var bth = byteToHex; // join used to fix memory issue caused by concatenation: https://bugs.chromium.org/p/v8/issues/detail?id=3175#c4\n\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\n function uuidv4() {\n var rnds = rng(); // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`\n\n rnds[6] = rnds[6] & 0x0f | 0x40;\n rnds[8] = rnds[8] & 0x3f | 0x80;\n return bytesToUuid(rnds);\n }\n\n function freeze(obj) {\n if (typeof Object.freeze === 'function') {\n return Object.freeze(obj);\n }\n\n return obj;\n }\n /**\n @module @ember-data/store\n */\n\n\n var configuredForgetMethod;\n var configuredGenerationMethod;\n var configuredResetMethod;\n var 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\n function defaultGenerationMethod(data, bucket) {\n if (isNonEmptyString(data.lid)) {\n return data.lid;\n }\n\n var type = data.type,\n id = data.id;\n\n if (isNonEmptyString(id)) {\n return \"@ember-data:lid-\" + normalizeModelName(type) + \"-\" + id;\n }\n\n return uuidv4();\n }\n\n var IdentifierCaches = new WeakMap();\n function identifierCacheFor(store) {\n var cache = IdentifierCaches.get(store);\n\n if (cache === undefined) {\n cache = new IdentifierCache();\n IdentifierCaches.set(store, cache);\n }\n\n return cache;\n }\n\n function defaultEmptyCallback() {}\n\n var DEBUG_MAP;\n\n {\n DEBUG_MAP = new WeakMap();\n }\n\n var IdentifierCache = /*#__PURE__*/function () {\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 function IdentifierCache() {\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 * 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 * @internal\n */\n\n\n var _proto = IdentifierCache.prototype;\n\n _proto.__configureMerge = function __configureMerge(method) {\n this._merge = method || defaultEmptyCallback;\n }\n /**\n * @internal\n */\n ;\n\n _proto._getRecordIdentifier = function _getRecordIdentifier(resource, shouldGenerate) {\n if (shouldGenerate === void 0) {\n shouldGenerate = false;\n }\n\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\n return resource;\n }\n\n var lid = coerceId(resource.lid);\n var identifier = lid !== null ? this._cache.lids[lid] : undefined;\n\n if (identifier !== undefined) {\n return identifier;\n }\n\n var type = normalizeModelName(resource.type);\n var id = coerceId(resource.id);\n\n if (shouldGenerate === false) {\n if (!type || !id) {\n return;\n }\n } // `type` must always be present\n\n\n {\n if (!isNonEmptyString(resource.type)) {\n throw new Error('resource.type needs to be a string');\n }\n }\n\n var keyOptions = getTypeIndex(this._cache.types, type); // go straight for the stable RecordIdentifier key'd to `lid`\n\n if (lid !== null) {\n identifier = keyOptions.lid[lid];\n } // we may have not seen this resource before\n // but just in case we check our own secondary lookup (`id`)\n\n\n if (identifier === undefined && id !== null) {\n identifier = keyOptions.id[id];\n }\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 var newLid = this._generate(resource, 'record'); // 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\n\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\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); // populate our unique table\n\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\n this._cache.lids[identifier.lid] = identifier; // populate our primary lookup table\n // TODO consider having the `lid` cache be\n // one level up\n\n keyOptions.lid[identifier.lid] = identifier; // TODO exists temporarily to support `peekAll`\n // but likely to move\n\n keyOptions._allIdentifiers.push(identifier);\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\n\n if (identifier.id !== null) {\n keyOptions.id[identifier.id] = identifier; // TODO allow filling out of `id` here\n // for the `username` non-client created\n // case.\n }\n }\n }\n\n return identifier;\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 * @internal\n */\n ;\n\n _proto.peekRecordIdentifier = function peekRecordIdentifier(resource) {\n return this._getRecordIdentifier(resource, false);\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 */\n ;\n\n _proto.getOrCreateRecordIdentifier = function getOrCreateRecordIdentifier(resource) {\n return this._getRecordIdentifier(resource, true);\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 */\n ;\n\n _proto.createIdentifierForNewRecord = function createIdentifierForNewRecord(data) {\n var newLid = this._generate(data, 'record');\n\n var identifier = makeStableRecordIdentifier(data.id || null, data.type, newLid, 'record', true);\n var keyOptions = getTypeIndex(this._cache.types, data.type); // populate our unique table\n\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\n this._cache.lids[identifier.lid] = identifier; // populate the type+lid cache\n\n keyOptions.lid[newLid] = identifier; // ensure a peekAll sees our new identifier too\n // TODO move this outta here?\n\n keyOptions._allIdentifiers.push(identifier);\n\n return identifier;\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 */\n ;\n\n _proto.updateRecordIdentifier = function updateRecordIdentifier(identifierObject, data) {\n var identifier = this.getOrCreateRecordIdentifier(identifierObject);\n var newId = coerceId(data.id);\n var existingIdentifier = detectMerge(this._cache.types, identifier, data, newId, this._cache.lids);\n\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 (data.type && identifier.type !== normalizeModelName(data.type)) {\n var incomingDataResource = Ember.assign({}, data); // Need to strip the lid from the incomingData in order force a new identifier creation\n\n delete incomingDataResource.lid;\n existingIdentifier = this.getOrCreateRecordIdentifier(incomingDataResource);\n }\n }\n\n if (existingIdentifier) {\n var keyOptions = getTypeIndex(this._cache.types, identifier.type);\n identifier = this._mergeRecordIdentifiers(keyOptions, identifier, existingIdentifier, data, newId);\n }\n\n var id = identifier.id;\n performRecordIdentifierUpdate(identifier, data, this._update);\n newId = identifier.id; // add to our own secondary lookup table\n\n if (id !== newId && newId !== null) {\n var _keyOptions = getTypeIndex(this._cache.types, identifier.type);\n\n _keyOptions.id[newId] = identifier;\n\n if (id !== null) {\n delete _keyOptions.id[id];\n }\n }\n\n return identifier;\n };\n\n _proto._mergeRecordIdentifiers = function _mergeRecordIdentifiers(keyOptions, identifier, existingIdentifier, data, newId) {\n // delegate determining which identifier to keep to the configured MergeMethod\n var kept = this._merge(identifier, existingIdentifier, data);\n\n var abandoned = kept === identifier ? existingIdentifier : identifier; // cleanup the identifier we no longer need\n\n this.forgetRecordIdentifier(abandoned); // ensure a secondary cache entry for this id for the identifier we do keep\n\n keyOptions.id[newId] = kept; // ensure a secondary cache entry for this id for the abandoned identifier's type we do keep\n\n var baseKeyOptions = getTypeIndex(this._cache.types, existingIdentifier.type);\n baseKeyOptions.id[newId] = kept; // make sure that the `lid` on the data we are processing matches the lid we kept\n\n data.lid = kept.lid;\n return kept;\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 */\n ;\n\n _proto.forgetRecordIdentifier = function forgetRecordIdentifier(identifierObject) {\n var identifier = this.getOrCreateRecordIdentifier(identifierObject);\n var keyOptions = getTypeIndex(this._cache.types, identifier.type);\n\n if (identifier.id !== null) {\n delete keyOptions.id[identifier.id];\n }\n\n delete this._cache.lids[identifier.lid];\n delete keyOptions.lid[identifier.lid];\n\n var index = keyOptions._allIdentifiers.indexOf(identifier);\n\n keyOptions._allIdentifiers.splice(index, 1);\n\n unmarkStableIdentifier(identifierObject);\n\n this._forget(identifier, 'record');\n };\n\n _proto.destroy = function destroy() {\n this._reset();\n };\n\n return IdentifierCache;\n }();\n\n function getTypeIndex(typeMap, type) {\n var typeIndex = typeMap[type];\n\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\n return typeIndex;\n }\n\n function makeStableRecordIdentifier(id, type, lid, bucket, clientOriginated) {\n if (clientOriginated === void 0) {\n clientOriginated = false;\n }\n\n var recordIdentifier = {\n lid: lid,\n id: id,\n type: type\n };\n markStableIdentifier(recordIdentifier);\n\n {\n // we enforce immutability in dev\n // but preserve our ability to do controlled updates to the reference\n var wrapper = {\n get lid() {\n return recordIdentifier.lid;\n },\n\n get id() {\n return recordIdentifier.id;\n },\n\n get type() {\n return recordIdentifier.type;\n },\n\n toString: function toString() {\n var type = recordIdentifier.type,\n id = recordIdentifier.id,\n lid = recordIdentifier.lid;\n return \"\" + (clientOriginated ? '[CLIENT_ORIGINATED] ' : '') + type + \":\" + id + \" (\" + lid + \")\";\n }\n };\n addSymbol(wrapper, DEBUG_CLIENT_ORIGINATED, clientOriginated);\n addSymbol(wrapper, DEBUG_IDENTIFIER_BUCKET, bucket);\n wrapper = freeze(wrapper);\n markStableIdentifier(wrapper);\n DEBUG_MAP.set(wrapper, recordIdentifier);\n return wrapper;\n }\n }\n\n function performRecordIdentifierUpdate(identifier, data, updateFn) {\n var id = data.id,\n lid = data.lid;\n var type = data.type && normalizeModelName(data.type);\n\n {\n // get the mutable instance behind our proxy wrapper\n var wrapper = identifier;\n identifier = DEBUG_MAP.get(wrapper);\n\n if (lid !== undefined) {\n var newLid = coerceId(lid);\n\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\n if (id !== undefined) {\n var newId = coerceId(id);\n\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 ( Ember.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 } // TODO consider just ignoring here to allow flexible polymorphic support\n\n\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\n updateFn(wrapper, data, 'record');\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\n\n if (id !== undefined) {\n identifier.id = coerceId(id);\n }\n }\n\n function detectMerge(typesCache, identifier, data, newId, lids) {\n var id = identifier.id,\n type = identifier.type,\n lid = identifier.lid;\n\n if (id !== null && id !== newId && newId !== null) {\n var keyOptions = getTypeIndex(typesCache, identifier.type);\n var existingIdentifier = keyOptions.id[newId];\n return existingIdentifier !== undefined ? existingIdentifier : false;\n } else {\n var newType = data.type && normalizeModelName(data.type); // If the ids and type are the same but lid is not the same, we should trigger a merge of the identifiers\n\n if (id !== null && id === newId && newType === type && data.lid && data.lid !== lid) {\n var _existingIdentifier = lids[data.lid];\n return _existingIdentifier !== undefined ? _existingIdentifier : false; // 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 var _keyOptions2 = getTypeIndex(typesCache, newType);\n\n var _existingIdentifier2 = _keyOptions2.id[id];\n return _existingIdentifier2 !== undefined ? _existingIdentifier2 : false;\n }\n }\n\n return false;\n }\n\n function constructResource(type, id, lid) {\n var trueId = coerceId(id);\n\n if (!isNonEmptyString(trueId)) {\n if (isNonEmptyString(lid)) {\n return {\n type: type,\n id: trueId,\n lid: lid\n };\n }\n\n throw new Error(\"Expected either id or lid to be a valid string\");\n }\n\n if (isNonEmptyString(lid)) {\n return {\n type: type,\n id: trueId,\n lid: lid\n };\n }\n\n return {\n type: type,\n id: trueId\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 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 @extends Ember.ArrayProxy\n @uses Ember.PromiseProxyMixin\n */\n var PromiseArray = Ember.ArrayProxy.extend(Ember.PromiseProxyMixin, {\n meta: Ember.computed.reads('content.meta')\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 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 @extends Ember.ObjectProxy\n @uses Ember.PromiseProxyMixin\n */\n\n var PromiseObject = Ember.ObjectProxy.extend(Ember.PromiseProxyMixin);\n function promiseObject(promise, label) {\n return PromiseObject.create({\n promise: Ember.RSVP.Promise.resolve(promise, label)\n });\n }\n function promiseArray(promise, label) {\n return PromiseArray.create({\n promise: Ember.RSVP.Promise.resolve(promise, label)\n });\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 var toReturn = internalModelPromise.then(function (internalModel) {\n return internalModel.getRecord();\n });\n return promiseObject(toReturn, label);\n }\n\n var backburner = new Ember._Backburner(['normalizeRelationships', 'syncRelationships', 'finished']);\n\n {\n Ember.Test.registerWaiter(function () {\n return !backburner.currentInstance && !backburner.hasTimers();\n });\n }\n\n /**\n @module @ember-data/store\n */\n var SOURCE_POINTER_REGEXP = /^\\/?data\\/(attributes|relationships)\\/(.*)/;\n var SOURCE_POINTER_PRIMARY_REGEXP = /^\\/?data/;\n var PRIMARY_ATTRIBUTE_KEY = 'base';\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 @public\n @param {Object} errors hash with errors as properties\n @return {Array} array of errors in JSON-API format\n */\n\n function errorsHashToArray(errors) {\n var out = [];\n\n if (Ember.isPresent(errors)) {\n Object.keys(errors).forEach(function (key) {\n var messages = Ember.makeArray(errors[key]);\n\n for (var i = 0; i < messages.length; i++) {\n var title = 'Invalid Attribute';\n var pointer = \"/data/attributes/\" + key;\n\n if (key === PRIMARY_ATTRIBUTE_KEY) {\n title = 'Invalid Document';\n pointer = \"/data\";\n }\n\n out.push({\n title: title,\n detail: messages[i],\n source: {\n pointer: pointer\n }\n });\n }\n });\n }\n\n return out;\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 @public\n @param {Array} errors array of errors in JSON-API format\n @return {Object}\n */\n\n function errorsArrayToHash(errors) {\n var out = {};\n\n if (Ember.isPresent(errors)) {\n errors.forEach(function (error) {\n if (error.source && error.source.pointer) {\n var key = error.source.pointer.match(SOURCE_POINTER_REGEXP);\n\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\n if (key) {\n out[key] = out[key] || [];\n out[key].push(error.detail || error.title);\n }\n }\n });\n }\n\n return out;\n }\n\n var RequestStateEnum;\n\n (function (RequestStateEnum) {\n RequestStateEnum[\"pending\"] = \"pending\";\n RequestStateEnum[\"fulfilled\"] = \"fulfilled\";\n RequestStateEnum[\"rejected\"] = \"rejected\";\n })(RequestStateEnum || (RequestStateEnum = {}));\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 function recordDataFor(instance) {\n var internalModel = instance._internalModel || instance.internalModel || instance;\n return internalModel._recordData || null;\n }\n\n function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\n function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }\n\n function relationshipsFor(instance) {\n var i = instance; // TODO this cast is not safe but it is the assumption of the current\n // state of the code. We need to update this class to handle CUSTOM_MODEL_CLASS\n // requirements.\n\n var recordData = i._internalModel._recordData;\n return recordData._relationships;\n }\n\n function relationshipStateFor(instance, propertyName) {\n return relationshipsFor(instance).get(propertyName);\n }\n\n /**\n @class Snapshot\n @private\n @constructor\n @param {Model} internalModel The model to create a snapshot from\n */\n var Snapshot = /*#__PURE__*/function () {\n function Snapshot(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._internalModel = void 0;\n this._changedAttributes = void 0;\n this.identifier = void 0;\n this.modelName = void 0;\n this.id = void 0;\n this.include = void 0;\n this.adapterOptions = void 0;\n this._store = _store;\n\n var internalModel = this._internalModel = _store._internalModelForResource(identifier);\n\n this.modelName = identifier.type;\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\n\n if (internalModel.hasRecord) {\n this._attributes;\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 */\n\n\n this.id = identifier.id;\n /**\n A hash of adapter options\n @property adapterOptions\n @type {Object}\n */\n\n this.adapterOptions = options.adapterOptions;\n /**\n @property include\n @type {String|Array}\n */\n\n this.include = options.include;\n /**\n The name of the type of the underlying record for this snapshot, as a string.\n @property modelName\n @type {String}\n */\n\n this.modelName = internalModel.modelName;\n\n if (internalModel.hasRecord) {\n this._changedAttributes = recordDataFor(internalModel).changedAttributes();\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 */\n\n\n var _proto = Snapshot.prototype;\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 */\n _proto.attr = function attr(keyName) {\n if (keyName in this._attributes) {\n return this._attributes[keyName];\n }\n\n ( Ember.assert(\"Model '\" + this.identifier + \"' has no attribute named '\" + keyName + \"' defined.\", false));\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 */\n ;\n\n _proto.attributes = function attributes() {\n return Ember.assign({}, this._attributes);\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 */\n ;\n\n _proto.changedAttributes = function changedAttributes() {\n var changedAttributes = Object.create(null);\n\n if (!this._changedAttributes) {\n return changedAttributes;\n }\n\n var changedAttributeKeys = Object.keys(this._changedAttributes);\n\n for (var i = 0, length = changedAttributeKeys.length; i < length; i++) {\n var _key = changedAttributeKeys[i];\n changedAttributes[_key] = this._changedAttributes[_key].slice();\n }\n\n return changedAttributes;\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 @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 ;\n\n _proto.belongsTo = function belongsTo(keyName, options) {\n var returnModeIsId = !!(options && options.id);\n var relationship;\n var inverseInternalModel;\n var result;\n var store = this._internalModel.store;\n\n if (returnModeIsId === true && keyName in this._belongsToIds) {\n return this._belongsToIds[keyName];\n }\n\n if (returnModeIsId === false && keyName in this._belongsToRelationships) {\n return this._belongsToRelationships[keyName];\n }\n\n var relationshipMeta = store._relationshipMetaFor(this.modelName, null, keyName);\n\n ( !(relationshipMeta && relationshipMeta.kind === 'belongsTo') && Ember.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 // TODO @runspired instead of casting here either generify relationship state or\n // provide a mechanism on relationship state by which to narrow.\n\n relationship = relationshipStateFor(this, keyName);\n var value = relationship.getData();\n var data = value && value.data;\n inverseInternalModel = data ? store._internalModelForResource(data) : null;\n\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\n if (returnModeIsId) {\n this._belongsToIds[keyName] = result;\n } else {\n this._belongsToRelationships[keyName] = result;\n }\n\n return result;\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 @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 ;\n\n _proto.hasMany = function hasMany(keyName, options) {\n var returnModeIsIds = !!(options && options.ids);\n var relationship;\n var results;\n var cachedIds = this._hasManyIds[keyName];\n var cachedSnapshots = this._hasManyRelationships[keyName];\n\n if (returnModeIsIds === true && keyName in this._hasManyIds) {\n return cachedIds;\n }\n\n if (returnModeIsIds === false && keyName in this._hasManyRelationships) {\n return cachedSnapshots;\n }\n\n var store = this._internalModel.store;\n\n var relationshipMeta = store._relationshipMetaFor(this.modelName, null, keyName);\n\n ( !(relationshipMeta && relationshipMeta.kind === 'hasMany') && Ember.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 // TODO @runspired instead of casting here either generify relationship state or\n // provide a mechanism on relationship state by which to narrow.\n\n relationship = relationshipStateFor(this, keyName);\n var value = relationship.getData();\n\n if (value.data) {\n results = [];\n value.data.forEach(function (member) {\n var internalModel = store._internalModelForResource(member);\n\n if (!internalModel.isDeleted()) {\n if (returnModeIsIds) {\n results.push(member.id);\n } else {\n results.push(internalModel.createSnapshot());\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\n\n if (returnModeIsIds) {\n this._hasManyIds[keyName] = results;\n } else {\n this._hasManyRelationships[keyName] = results;\n }\n\n return results;\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 */\n ;\n\n _proto.eachAttribute = function eachAttribute(callback, binding) {\n {\n // in the non CUSTOM_MODEL_CLASS world we only have DSModel instances\n this.record.eachAttribute(callback, binding);\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 */\n ;\n\n _proto.eachRelationship = function eachRelationship(callback, binding) {\n {\n // in the non CUSTOM_MODEL_CLASS world we only have DSModel instances\n this.record.eachRelationship(callback, binding);\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 */\n ;\n\n _proto.serialize = function serialize(options) {\n return this._store.serializerFor(this.modelName).serialize(this, options);\n };\n\n _createClass(Snapshot, [{\n key: \"record\",\n get: function get() {\n return this._internalModel.getRecord();\n }\n }, {\n key: \"_attributes\",\n get: function get() {\n\n if (this.__attributes !== null) {\n return this.__attributes;\n }\n\n var record = this.record;\n var attributes = this.__attributes = Object.create(null);\n var attrs;\n\n {\n attrs = Object.keys(this._store._attributesDefinitionFor(this.modelName));\n }\n\n {\n // When CUSTOM_MODEL_CLASS is false `record` must be DSModel\n record.eachAttribute(function (keyName) {\n return attributes[keyName] = Ember.get(record, keyName);\n });\n }\n\n return attributes;\n }\n /**\n The type of the underlying record for this snapshot, as a Model.\n @property type\n @type {Model}\n */\n\n }, {\n key: \"type\",\n get: function get() {\n return this._internalModel.modelClass;\n }\n }, {\n key: \"isNew\",\n get: function get() {\n {\n throw new Error('isNew is only available when custom model class ff is on');\n }\n }\n }]);\n\n return Snapshot;\n }();\n\n /**\n @module @ember-data/store\n */\n function _bind(fn) {\n for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n args[_key - 1] = arguments[_key];\n }\n\n return function () {\n return fn.apply(undefined, args);\n };\n }\n function _guard(promise, test) {\n var guarded = promise.finally(function () {\n if (!test()) {\n guarded._subscribers.length = 0;\n }\n });\n return guarded;\n }\n function _objectIsAlive(object) {\n return !(Ember.get(object, 'isDestroyed') || Ember.get(object, 'isDestroying'));\n }\n function guardDestroyedStore(promise, store, label) {\n var token;\n\n {\n token = store._trackAsyncRequestStart(label);\n }\n\n var wrapperPromise = Ember.RSVP.resolve(promise, label).then(function (v) {\n return promise;\n });\n return _guard(wrapperPromise, function () {\n {\n store._trackAsyncRequestEnd(token);\n }\n\n return _objectIsAlive(store);\n });\n }\n\n /**\n @module @ember-data/store\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 @method validateDocumentStructure\n @param {Object} doc JSON API document\n @return {array} An array of errors found in the document structure\n */\n function validateDocumentStructure(doc) {\n var errors = [];\n\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\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\n if ('meta' in doc) {\n if (typeof doc.meta !== 'object') {\n errors.push('meta must be an object');\n }\n }\n\n if ('errors' in doc) {\n if (!Array.isArray(doc.errors)) {\n errors.push('errors must be an array');\n }\n }\n\n if ('links' in doc) {\n if (typeof doc.links !== 'object') {\n errors.push('links must be an object');\n }\n }\n\n if ('jsonapi' in doc) {\n if (typeof doc.jsonapi !== 'object') {\n errors.push('jsonapi must be an object');\n }\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\n return errors;\n }\n /*\n This is a helper method that always returns a JSON-API Document.\n\n @method normalizeResponseHelper\n @param {Serializer} serializer\n @param {Store} store\n @param {subclass of Model} modelClass\n @param {Object} payload\n @param {String|Number} id\n @param {String} requestType\n @return {Object} JSON-API Document\n */\n\n function normalizeResponseHelper(serializer, store, modelClass, payload, id, requestType) {\n var normalizedResponse = serializer.normalizeResponse(store, modelClass, payload, id, requestType);\n var validationErrors = [];\n\n {\n validationErrors = validateDocumentStructure(normalizedResponse);\n }\n\n ( !(validationErrors.length === 0) && Ember.assert(\"normalizeResponse must return a valid JSON API document:\\n\\t* \" + validationErrors.join('\\n\\t* '), validationErrors.length === 0));\n return normalizedResponse;\n }\n\n var emberRun = Ember.run.backburner;\n\n /**\n @module @ember-data/store\n */\n var INSTANCE_DEPRECATIONS;\n var lookupDeprecations;\n var DeprecatedEvented;\n\n {\n INSTANCE_DEPRECATIONS = new WeakMap();\n\n lookupDeprecations = function lookupInstanceDrecations(instance) {\n var deprecations = INSTANCE_DEPRECATIONS.get(instance);\n\n if (!deprecations) {\n deprecations = {};\n INSTANCE_DEPRECATIONS.set(instance, deprecations);\n }\n\n return deprecations;\n };\n\n DeprecatedEvented = Ember.Mixin.create(Ember.Evented, {\n /**\n * Provides a way to call Evented without logging deprecation warnings\n * @param {String} name\n */\n _has: function _has(name) {\n return Ember.Evented.mixins[0].properties.has.call(this, name);\n },\n _on: function _on() {\n var _Ember$Evented$mixins;\n\n return (_Ember$Evented$mixins = Ember.Evented.mixins[0].properties.on).call.apply(_Ember$Evented$mixins, [this].concat(Array.prototype.slice.call(arguments)));\n },\n _deprecateEvented: function _deprecateEvented(eventName) {\n var deprecations = lookupDeprecations(this);\n\n var _deprecationData = this._getDeprecatedEventedInfo ? \"on \" + this._getDeprecatedEventedInfo() : '';\n\n var deprecationMessage = _deprecationData ? \"Called \" + eventName + \" \" + _deprecationData : eventName;\n ( !(deprecations[eventName]) && Ember.deprecate(deprecationMessage, deprecations[eventName], {\n id: 'ember-data:evented-api-usage',\n until: '4.0',\n url: 'https://deprecations.emberjs.com/ember-data/v3.x/#deprecatingrecordlifecycleeventmethods'\n }));\n deprecations[eventName] = true;\n },\n has: function has(name) {\n this._deprecateEvented(name);\n\n return this._super.apply(this, arguments);\n },\n off: function off(name, target, method) {\n this._deprecateEvented(name);\n\n return this._super.apply(this, arguments);\n },\n on: function on(name, target, method) {\n this._deprecateEvented(name);\n\n return this._super.apply(this, arguments);\n },\n one: function one(name, target, method) {\n this._deprecateEvented(name);\n\n return this._super.apply(this, arguments);\n },\n trigger: function trigger(name) {\n this._deprecateEvented(name);\n\n return this._super.apply(this, arguments);\n }\n });\n }\n\n var DeprecatedEvented$1 = DeprecatedEvented ;\n\n function _defineProperties$1(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\n function _createClass$1(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1(Constructor, staticProps); return Constructor; }\n\n /**\n @module @ember-data/store\n */\n\n /**\n @class SnapshotRecordArray\n @private\n @constructor\n @param {Array} snapshots An array of snapshots\n @param {Object} meta\n */\n var SnapshotRecordArray = /*#__PURE__*/function () {\n function SnapshotRecordArray(recordArray, meta, options) {\n if (options === void 0) {\n options = {};\n }\n\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 /**\n An array of snapshots\n @private\n @property _snapshots\n @type {Array}\n */\n this._snapshots = null;\n /**\n An array of records\n @private\n @property _recordArray\n @type {Array}\n */\n\n this._recordArray = recordArray;\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 @type {Number}\n */\n\n this.length = recordArray.get('length');\n this._type = null;\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 @type {Object}\n */\n\n this.meta = meta;\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 @type {Object}\n */\n\n this.adapterOptions = options.adapterOptions;\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 @type {String|Array}\n */\n\n this.include = options.include;\n }\n /**\n The type of the underlying records for the snapshots in the array, as a Model\n @property type\n @type {Model}\n */\n\n\n var _proto = SnapshotRecordArray.prototype;\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 @return {Array} Array of snapshots\n */\n _proto.snapshots = function snapshots() {\n if (this._snapshots !== null) {\n return this._snapshots;\n }\n\n this._snapshots = this._recordArray._takeSnapshot();\n return this._snapshots;\n };\n\n _createClass$1(SnapshotRecordArray, [{\n key: \"type\",\n get: function get() {\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 type\n @type {Model}\n */\n\n }, {\n key: \"modelName\",\n get: function get() {\n return this._recordArray.modelName;\n }\n }]);\n\n return SnapshotRecordArray;\n }();\n\n function _defineProperties$2(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\n function _createClass$2(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$2(Constructor.prototype, protoProps); if (staticProps) _defineProperties$2(Constructor, staticProps); return Constructor; }\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 @private\n */\n var InternalModelMap = /*#__PURE__*/function () {\n function InternalModelMap(modelName) {\n this._idToModel = Object.create(null);\n this._models = [];\n this._metadata = null;\n this.modelName = modelName;\n }\n /**\n * @method get\n * @param id {String}\n * @return {InternalModel}\n */\n\n\n var _proto = InternalModelMap.prototype;\n\n _proto.get = function get(id) {\n return this._idToModel[id] || null;\n };\n\n _proto.has = function has(id) {\n return !!this._idToModel[id];\n };\n\n _proto.set = function set(id, internalModel) {\n ( !(typeof id === 'string' && id.length > 0) && Ember.assert(\"You cannot index an internalModel by an empty id'\", typeof id === 'string' && id.length > 0));\n ( !(internalModel instanceof InternalModel) && Ember.assert(\"You cannot set an index for an internalModel to something other than an internalModel\", internalModel instanceof InternalModel));\n ( !(this.contains(internalModel)) && Ember.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) && Ember.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\n _proto.add = function add(internalModel, id) {\n ( !(!this.contains(internalModel)) && Ember.assert(\"You cannot re-add an already present InternalModel to the InternalModelMap.\", !this.contains(internalModel)));\n\n if (id) {\n ( !(!this.has(id) || this.get(id) === internalModel) && Ember.assert(\"Duplicate InternalModel for \" + this.modelName + \":\" + id + \" detected.\", !this.has(id) || this.get(id) === internalModel));\n this._idToModel[id] = internalModel;\n }\n\n this._models.push(internalModel);\n };\n\n _proto.remove = function remove(internalModel, id) {\n delete this._idToModel[id];\n\n var loc = this._models.indexOf(internalModel);\n\n if (loc !== -1) {\n this._models.splice(loc, 1);\n }\n };\n\n _proto.contains = function contains(internalModel) {\n return this._models.indexOf(internalModel) !== -1;\n }\n /**\n An array of all models of this modelName\n @property models\n @type Array\n */\n ;\n\n /**\n Destroy all models in the internalModelTest and wipe metadata.\n @method clear\n */\n _proto.clear = function clear() {\n var internalModels = this._models;\n this._models = [];\n\n for (var i = 0; i < internalModels.length; i++) {\n var internalModel = internalModels[i];\n internalModel.unloadRecord();\n }\n\n this._metadata = null;\n };\n\n _createClass$2(InternalModelMap, [{\n key: \"length\",\n get: function get() {\n return this._models.length;\n }\n }, {\n key: \"recordIdentifiers\",\n get: function get() {\n return this._models.map(function (m) {\n return m.identifier;\n });\n }\n }, {\n key: \"models\",\n get: function get() {\n return this._models;\n }\n /**\n * meta information about internalModels\n * @property metadata\n * @type Object\n */\n\n }, {\n key: \"metadata\",\n get: function get() {\n return this._metadata || (this._metadata = Object.create(null));\n }\n }]);\n\n return InternalModelMap;\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 @private\n */\n var IdentityMap = /*#__PURE__*/function () {\n function IdentityMap() {\n this._map = Object.create(null);\n }\n\n var _proto = IdentityMap.prototype;\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 @param modelName a previously normalized modelName\n @return {InternalModelMap} the InternalModelMap for the given modelName\n */\n _proto.retrieve = function retrieve(modelName) {\n var map = this._map[modelName];\n\n if (map === undefined) {\n map = this._map[modelName] = new InternalModelMap(modelName);\n }\n\n return map;\n }\n /**\n Clears the contents of all known `RecordMaps`, but does\n not remove the InternalModelMap instances.\n @method clear\n */\n ;\n\n _proto.clear = function clear() {\n var map = this._map;\n var keys = Object.keys(map);\n\n for (var i = 0; i < keys.length; i++) {\n var key = keys[i];\n map[key].clear();\n }\n };\n\n return IdentityMap;\n }();\n\n /**\n @module @ember-data/store\n */\n var FactoryCache = new WeakMap();\n var RecordCache = new WeakMap();\n function peekRecordIdentifier(record) {\n return RecordCache.get(record);\n }\n function recordIdentifierFor(record) {\n var identifier = RecordCache.get(record);\n\n if ( identifier === undefined) {\n throw new Error(record + \" is not a record instantiated by @ember-data/store\");\n }\n\n return identifier;\n }\n function setRecordIdentifier(record, identifier) {\n if ( RecordCache.has(record)) {\n throw new Error(record + \" was already assigned an identifier\");\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\n RecordCache.set(record, identifier);\n }\n function internalModelFactoryFor(store) {\n var factory = FactoryCache.get(store);\n\n if (factory === undefined) {\n factory = new InternalModelFactory(store);\n FactoryCache.set(store, factory);\n }\n\n return factory;\n }\n /**\n * The InternalModelFactory handles the lifecyle of\n * instantiating, caching, and destroying InternalModel\n * instances.\n *\n * @internal\n */\n\n var InternalModelFactory = /*#__PURE__*/function () {\n function InternalModelFactory(store) {\n var _this = this;\n\n this._identityMap = void 0;\n this._newlyCreated = void 0;\n this.identifierCache = void 0;\n this.store = store;\n this.identifierCache = identifierCacheFor(store);\n\n this.identifierCache.__configureMerge(function (identifier, matchedIdentifier, resourceData) {\n var intendedIdentifier = identifier;\n\n if (identifier.id !== matchedIdentifier.id) {\n intendedIdentifier = identifier.id === resourceData.id ? identifier : matchedIdentifier;\n } else if (identifier.type !== matchedIdentifier.type) {\n intendedIdentifier = identifier.type === resourceData.type ? identifier : matchedIdentifier;\n }\n\n var altIdentifier = identifier === intendedIdentifier ? matchedIdentifier : identifier; // check for duplicate InternalModel's\n\n var map = _this.modelMapFor(identifier.type);\n\n var im = map.get(intendedIdentifier.lid);\n var otherIm = map.get(altIdentifier.lid); // 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\n if (im && otherIm && im.hasRecord && otherIm.hasRecord) {\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 } // remove otherIm from cache\n\n\n if (otherIm) {\n map.remove(otherIm, altIdentifier.lid);\n }\n\n if (im === null && otherIm === null) {\n // nothing more to do\n return intendedIdentifier; // 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); // im.destroy();\n }\n\n im = otherIm; // TODO do we need to notify the id change?\n\n im._id = intendedIdentifier.id;\n map.add(im, intendedIdentifier.lid); // just use im\n }\n\n return intendedIdentifier;\n });\n\n this._identityMap = new IdentityMap();\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 * @internal\n */\n\n\n var _proto = InternalModelFactory.prototype;\n\n _proto.lookup = function 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\n var identifier = this.identifierCache.getOrCreateRecordIdentifier(resource);\n var internalModel = this.peek(identifier);\n\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\n return internalModel;\n }\n\n return this._build(identifier, false);\n }\n /**\n * Peek the InternalModel for a given { type, id, lid }.\n *\n * If an InternalModel does not exist, return `null`.\n *\n * @internal\n */\n ;\n\n _proto.peek = function peek(identifier) {\n return this.modelMapFor(identifier.type).get(identifier.lid);\n };\n\n _proto.getByResource = function getByResource(resource) {\n var normalizedResource = constructResource(resource.type, resource.id, resource.lid);\n return this.lookup(normalizedResource);\n };\n\n _proto.setRecordId = function setRecordId(type, id, lid) {\n var resource = {\n type: type,\n id: null,\n lid: lid\n };\n var identifier = this.identifierCache.getOrCreateRecordIdentifier(resource);\n var internalModel = this.peek(identifier);\n\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\n var oldId = internalModel.id;\n var modelName = internalModel.modelName; // ID absolutely can't be missing if the oldID is empty (missing Id in response for a new record)\n\n ( !(!(id === null && oldId === null)) && Ember.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\n ( !(!(oldId !== null && id !== oldId)) && Ember.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\n if (oldId !== null && id === null) {\n ( Ember.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\n var existingInternalModel = this.peekById(modelName, id);\n ( !(Ember.isNone(existingInternalModel) || existingInternalModel === internalModel) && Ember.assert(\"'\" + modelName + \"' was saved to the server, but the response returned the new id '\" + id + \"', which has already been used with another record.'\", Ember.isNone(existingInternalModel) || existingInternalModel === internalModel));\n\n if (identifier.id === null) {\n this.identifierCache.updateRecordIdentifier(identifier, {\n type: type,\n id: id\n });\n }\n\n internalModel.setId(id);\n };\n\n _proto.peekById = function peekById(type, id) {\n var identifier = this.identifierCache.peekRecordIdentifier({\n type: type,\n id: id\n });\n var internalModel = identifier ? this.modelMapFor(type).get(identifier.lid) : null;\n\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\n return internalModel;\n };\n\n _proto.build = function build(newResourceInfo) {\n return this._build(newResourceInfo, true);\n };\n\n _proto._build = function _build(resource, isCreate) {\n if (isCreate === void 0) {\n isCreate = false;\n }\n\n if (isCreate === true && resource.id) {\n var existingInternalModel = this.peekById(resource.type, resource.id);\n ( !(!existingInternalModel) && Ember.assert(\"The id \" + resource.id + \" has already been used with another '\" + resource.type + \"' record.\", !existingInternalModel));\n }\n\n var identifierCache = this.identifierCache;\n var identifier;\n\n if (isCreate === true) {\n identifier = identifierCache.createIdentifierForNewRecord(resource);\n } else {\n identifier = resource;\n } // lookupFactory should really return an object that creates\n // instances with the injections applied\n\n\n var internalModel = new InternalModel(this.store, identifier);\n this.modelMapFor(resource.type).add(internalModel, identifier.lid);\n return internalModel;\n };\n\n _proto.remove = function remove(internalModel) {\n var recordMap = this.modelMapFor(internalModel.modelName);\n var clientId = internalModel.identifier.lid;\n recordMap.remove(internalModel, clientId);\n var identifier = internalModel.identifier;\n this.identifierCache.forgetRecordIdentifier(identifier);\n };\n\n _proto.modelMapFor = function modelMapFor(type) {\n return this._identityMap.retrieve(type);\n };\n\n _proto._newlyCreatedModelsFor = function _newlyCreatedModelsFor(type) {\n return this._newlyCreated.retrieve(type);\n };\n\n _proto.clear = function clear(type) {\n if (type === undefined) {\n this._identityMap.clear();\n } else {\n this.modelMapFor(type).clear();\n }\n };\n\n return InternalModelFactory;\n }();\n\n function recordForIdentifier(store, identifier) {\n return internalModelFactoryFor(store).lookup(identifier).getRecord();\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 @class RecordArray\n @extends ArrayProxy\n @uses Ember.Evented\n */\n\n\n var RecordArray = Ember.ArrayProxy.extend(DeprecatedEvented$1, {\n init: function init(args) {\n var _this = this;\n\n this._super(args);\n\n {\n this._getDeprecatedEventedInfo = function () {\n return \"RecordArray containing \" + _this.modelName;\n };\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\n\n this.set('content', this.content || null);\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 @type Boolean\n */\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 @type Boolean\n */\n\n this.isUpdating = false;\n /**\n The store that created this record array.\n @property store\n @private\n @type Store\n */\n\n this.store = this.store || null;\n this._updatingPromise = null;\n },\n replace: function 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 /**\n The modelClass represented by this record array.\n @property type\n @type Model\n */\n type: Ember.computed('modelName', function () {\n if (!this.modelName) {\n return null;\n }\n\n return this.store.modelFor(this.modelName);\n }).readOnly(),\n\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: function objectAtContent(index) {\n var identifier = Ember.get(this, 'content').objectAt(index);\n return identifier ? recordForIdentifier(this.store, identifier) : undefined;\n },\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 */\n update: function update() {\n var _this2 = this;\n\n if (Ember.get(this, 'isUpdating')) {\n return this._updatingPromise;\n }\n\n this.set('isUpdating', true);\n\n var updatingPromise = this._update().finally(function () {\n _this2._updatingPromise = null;\n\n if (_this2.get('isDestroying') || _this2.get('isDestroyed')) {\n return;\n }\n\n _this2.set('isUpdating', false);\n });\n\n this._updatingPromise = updatingPromise;\n return updatingPromise;\n },\n\n /*\n Update this RecordArray and return a promise which resolves once the update\n is finished.\n */\n _update: function _update() {\n return this.store.findAll(this.modelName, {\n reload: true\n });\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 @return {PromiseArray} promise\n */\n save: function save() {\n var _this3 = this;\n\n var promiseLabel = \"DS: RecordArray#save \" + this.modelName;\n var promise = Ember.RSVP.Promise.all(this.invoke('save'), promiseLabel).then(function () {\n return _this3;\n }, null, 'DS: RecordArray#save return RecordArray');\n return PromiseArray.create({\n promise: promise\n });\n },\n\n /**\n @method _unregisterFromManager\n @private\n */\n _unregisterFromManager: function _unregisterFromManager() {\n this.manager.unregisterRecordArray(this);\n },\n willDestroy: function willDestroy() {\n this._unregisterFromManager();\n\n this._dissociateFromOwnRecords(); // 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\n\n Ember.set(this, 'content', null);\n Ember.set(this, 'length', 0);\n\n this._super.apply(this, arguments);\n },\n\n /*\n @method _createSnapshot\n @private\n */\n _createSnapshot: function _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 /**\n @method _dissociateFromOwnRecords\n @internal\n */\n _dissociateFromOwnRecords: function _dissociateFromOwnRecords() {\n var _this4 = this;\n\n this.get('content').forEach(function (identifier) {\n var recordArrays = _this4.manager.getRecordArraysForIdentifier(identifier);\n\n if (recordArrays) {\n recordArrays.delete(_this4);\n }\n });\n },\n\n /**\n Adds identifiers to the `RecordArray` without duplicates\n @method _pushIdentifiers\n @internal\n @param {StableRecordIdentifier[]} identifiers\n */\n _pushIdentifiers: function _pushIdentifiers(identifiers) {\n Ember.get(this, 'content').pushObjects(identifiers);\n },\n\n /**\n Removes identifiers from the `RecordArray`.\n @method _removeIdentifiers\n @internal\n @param {StableRecordIdentifier[]} identifiers\n */\n _removeIdentifiers: function _removeIdentifiers(identifiers) {\n Ember.get(this, 'content').removeObjects(identifiers);\n },\n\n /**\n @method _takeSnapshot\n @internal\n */\n _takeSnapshot: function _takeSnapshot() {\n var _this5 = this;\n\n return Ember.get(this, 'content').map(function (identifier) {\n return internalModelFactoryFor(_this5.store).lookup(identifier).createSnapshot();\n });\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 ---\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 @extends RecordArray\n */\n\n var AdapterPopulatedRecordArray = RecordArray.extend({\n init: function init() {\n var _this = this;\n\n this.set('content', this.get('content') || Ember.A());\n\n this._super.apply(this, arguments);\n\n this.query = this.query || null;\n this.links = this.links || null;\n\n {\n this._getDeprecatedEventedInfo = function () {\n return \"AdapterPopulatedRecordArray containing \" + _this.modelName + \" for query: \" + _this.query;\n };\n }\n },\n replace: function replace() {\n throw new Error(\"The result of a server query (on \" + this.modelName + \") is immutable.\");\n },\n _update: function _update() {\n var store = Ember.get(this, 'store');\n var query = Ember.get(this, 'query');\n return store._query(this.modelName, query, this);\n },\n _setObjects: function _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: Ember.assign({}, payload.meta),\n links: Ember.assign({}, payload.links)\n });\n\n this.manager._associateWithRecordArray(identifiersOrInternalModels, this);\n\n {\n var _hasDidLoad = this._has('didLoad') ;\n\n if (_hasDidLoad) {\n // TODO: should triggering didLoad event be the last action of the runLoop?\n Ember.run.once(this, 'trigger', 'didLoad');\n }\n }\n },\n\n /**\n @method _setIdentifiers\n @param {StableRecordIdentifier[]} identifiers\n @param {Object} payload normalized payload\n @internal\n */\n _setIdentifiers: function _setIdentifiers(identifiers, payload) {\n this._setObjects(identifiers, payload);\n }\n });\n\n var RecordArraysCache = new WeakMap();\n var emberRun$1 = Ember.run.backburner;\n function recordArraysForIdentifier(identifierOrInternalModel) {\n if (RecordArraysCache.has(identifierOrInternalModel)) {\n // return existing Set if exists\n return RecordArraysCache.get(identifierOrInternalModel);\n } // returns workable Set instance\n\n\n RecordArraysCache.set(identifierOrInternalModel, new Set());\n return RecordArraysCache.get(identifierOrInternalModel);\n }\n var pendingForIdentifier = new Set([]);\n var IMDematerializing = new WeakMap();\n\n var getIdentifier = function getIdentifier(identifierOrInternalModel) {\n var i = identifierOrInternalModel;\n\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\n return i;\n }; // REMOVE_RECORD_ARRAY_MANAGER_LEGACY_COMPAT only\n\n\n var peekIMCache = function peekIMCache(cache, identifier) {\n {\n var im = IMDematerializing.get(identifier);\n\n if (im === undefined) {\n // if not im._isDematerializing\n im = cache.peek(identifier);\n }\n\n return im;\n }\n };\n\n var shouldIncludeInRecordArrays = function shouldIncludeInRecordArrays(store, identifier) {\n var cache = internalModelFactoryFor(store);\n var internalModel = cache.peek(identifier);\n\n if (internalModel === null) {\n return false;\n }\n\n return !internalModel.isHiddenFromRecordArrays();\n };\n /**\n @class RecordArrayManager\n @private\n */\n\n\n var RecordArrayManager = /*#__PURE__*/function () {\n function RecordArrayManager(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 * @method getRecordArraysForIdentifier\n * @public\n * @param {StableIdentifier} param\n * @return {RecordArray} array\n */\n\n\n var _proto = RecordArrayManager.prototype;\n\n _proto.getRecordArraysForIdentifier = function getRecordArraysForIdentifier(identifier) {\n return recordArraysForIdentifier(identifier);\n };\n\n _proto._flushPendingIdentifiersForModelName = function _flushPendingIdentifiersForModelName(modelName, identifiers) {\n if (this.isDestroying || this.isDestroyed) {\n return;\n }\n\n var modelsToRemove = [];\n\n for (var j = 0; j < identifiers.length; j++) {\n var i = identifiers[j]; // mark identifiers, so they can once again be processed by the\n // recordArrayManager\n\n pendingForIdentifier.delete(i); // build up a set of models to ensure we have purged correctly;\n\n var isIncluded = shouldIncludeInRecordArrays(this.store, i);\n\n if (!isIncluded) {\n modelsToRemove.push(i);\n }\n }\n\n var array = this._liveRecordArrays[modelName];\n\n if (array) {\n // TODO: skip if it only changed\n // process liveRecordArrays\n updateLiveRecordArray(this.store, array, identifiers);\n } // process adapterPopulatedRecordArrays\n\n\n if (modelsToRemove.length > 0) {\n removeFromAdapterPopulatedRecordArrays(this.store, modelsToRemove);\n }\n };\n\n _proto._flush = function _flush() {\n var pending = this._pendingIdentifiers;\n this._pendingIdentifiers = Object.create(null);\n\n for (var modelName in pending) {\n this._flushPendingIdentifiersForModelName(modelName, pending[modelName]);\n }\n };\n\n _proto._syncLiveRecordArray = function _syncLiveRecordArray(array, modelName) {\n ( !(typeof modelName === 'string') && Ember.assert(\"recordArrayManger.syncLiveRecordArray expects modelName not modelClass as the second param\", typeof modelName === 'string'));\n var pending = this._pendingIdentifiers[modelName];\n var hasPendingChanges = Array.isArray(pending);\n var hasNoPotentialDeletions = !hasPendingChanges || pending.length === 0;\n var map = internalModelFactoryFor(this.store).modelMapFor(modelName);\n var hasNoInsertionsOrRemovals = Ember.get(map, 'length') === Ember.get(array, 'length');\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\n if (hasNoPotentialDeletions && hasNoInsertionsOrRemovals) {\n return;\n }\n\n if (hasPendingChanges) {\n this._flushPendingIdentifiersForModelName(modelName, pending);\n\n delete this._pendingIdentifiers[modelName];\n }\n\n var identifiers = this._visibleIdentifiersByType(modelName);\n\n var modelsToAdd = [];\n\n for (var i = 0; i < identifiers.length; i++) {\n var identifier = identifiers[i];\n var recordArrays = recordArraysForIdentifier(identifier);\n\n if (recordArrays.has(array) === false) {\n recordArrays.add(array);\n modelsToAdd.push(identifier);\n }\n }\n\n if (modelsToAdd.length) {\n array._pushIdentifiers(modelsToAdd);\n }\n };\n\n _proto._didUpdateAll = function _didUpdateAll(modelName) {\n var recordArray = this._liveRecordArrays[modelName];\n\n if (recordArray) {\n Ember.set(recordArray, 'isUpdating', false);\n }\n }\n /**\n Get the `RecordArray` for a modelName, which contains all loaded records of\n given modelName.\n @method liveRecordArrayFor\n @param {String} modelName\n @return {RecordArray}\n */\n ;\n\n _proto.liveRecordArrayFor = function liveRecordArrayFor(modelName) {\n ( !(typeof modelName === 'string') && Ember.assert(\"recordArrayManger.liveRecordArrayFor expects modelName not modelClass as the param\", typeof modelName === 'string'));\n var array = this._liveRecordArrays[modelName];\n\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 var identifiers = this._visibleIdentifiersByType(modelName);\n\n array = this.createRecordArray(modelName, identifiers);\n this._liveRecordArrays[modelName] = array;\n }\n\n return array;\n };\n\n _proto._visibleIdentifiersByType = function _visibleIdentifiersByType(modelName) {\n var all = internalModelFactoryFor(this.store).modelMapFor(modelName).recordIdentifiers;\n var visible = [];\n\n for (var i = 0; i < all.length; i++) {\n var identifier = all[i];\n var shouldInclude = shouldIncludeInRecordArrays(this.store, identifier);\n\n if (shouldInclude) {\n visible.push(identifier);\n }\n }\n\n return visible;\n }\n /**\n Create a `RecordArray` for a modelName.\n @method createRecordArray\n @param {String} modelName\n @param {Array} [identifiers]\n @return {RecordArray}\n */\n ;\n\n _proto.createRecordArray = function createRecordArray(modelName, identifiers) {\n ( !(typeof modelName === 'string') && Ember.assert(\"recordArrayManger.createRecordArray expects modelName not modelClass as the param\", typeof modelName === 'string'));\n var array = RecordArray.create({\n modelName: modelName,\n content: Ember.A(identifiers || []),\n store: this.store,\n isLoaded: true,\n manager: this\n });\n\n if (Array.isArray(identifiers)) {\n this._associateWithRecordArray(identifiers, array);\n }\n\n return array;\n }\n /**\n Create a `AdapterPopulatedRecordArray` for a modelName with given query.\n @method createAdapterPopulatedRecordArray\n @param {String} modelName\n @param {Object} query\n @return {AdapterPopulatedRecordArray}\n */\n ;\n\n _proto.createAdapterPopulatedRecordArray = function createAdapterPopulatedRecordArray(modelName, query, identifiers, payload) {\n ( !(typeof modelName === 'string') && Ember.assert(\"recordArrayManger.createAdapterPopulatedRecordArray expects modelName not modelClass as the first param, received \" + modelName, typeof modelName === 'string'));\n var array;\n\n if (Array.isArray(identifiers)) {\n array = AdapterPopulatedRecordArray.create({\n modelName: modelName,\n query: query,\n content: Ember.A(identifiers),\n store: this.store,\n manager: this,\n isLoaded: true,\n isUpdating: false,\n meta: Ember.assign({}, payload.meta),\n links: Ember.assign({}, payload.links)\n });\n\n this._associateWithRecordArray(identifiers, array);\n } else {\n array = AdapterPopulatedRecordArray.create({\n modelName: modelName,\n query: query,\n content: Ember.A(),\n store: this.store,\n manager: this\n });\n }\n\n this._adapterPopulatedRecordArrays.push(array);\n\n return array;\n }\n /**\n Unregister a RecordArray.\n So manager will not update this array.\n @method unregisterRecordArray\n @param {RecordArray} array\n */\n ;\n\n _proto.unregisterRecordArray = function unregisterRecordArray(array) {\n var modelName = array.modelName; // remove from adapter populated record array\n\n var removedFromAdapterPopulated = removeFromArray(this._adapterPopulatedRecordArrays, array);\n\n if (!removedFromAdapterPopulated) {\n var liveRecordArrayForType = this._liveRecordArrays[modelName]; // unregister live record array\n\n if (liveRecordArrayForType) {\n if (array === liveRecordArrayForType) {\n delete this._liveRecordArrays[modelName];\n }\n }\n }\n }\n /**\n * @method _associateWithRecordArray\n * @private\n * @param {StableIdentifier} identifiers\n * @param {RecordArray} array\n */\n ;\n\n _proto._associateWithRecordArray = function _associateWithRecordArray(identifiers, array) {\n for (var i = 0, l = identifiers.length; i < l; i++) {\n var identifier = identifiers[i];\n identifier = getIdentifier(identifier);\n var recordArrays = this.getRecordArraysForIdentifier(identifier);\n recordArrays.add(array);\n }\n }\n /**\n @method recordDidChange\n @internal\n */\n ;\n\n _proto.recordDidChange = function recordDidChange(identifier) {\n if (this.isDestroying || this.isDestroyed) {\n return;\n }\n\n var modelName = identifier.type;\n identifier = getIdentifier(identifier);\n\n {\n var cache = internalModelFactoryFor(this.store);\n var im = peekIMCache(cache, identifier);\n\n if (im && im._isDematerializing) {\n IMDematerializing.set(identifier, im);\n }\n }\n\n if (pendingForIdentifier.has(identifier)) {\n return;\n }\n\n pendingForIdentifier.add(identifier);\n var pending = this._pendingIdentifiers;\n var models = pending[modelName] = pending[modelName] || [];\n\n if (models.push(identifier) !== 1) {\n return;\n }\n\n emberRun$1.schedule('actions', this, this._flush);\n };\n\n _proto.willDestroy = function willDestroy() {\n var _this = this;\n\n Object.keys(this._liveRecordArrays).forEach(function (modelName) {\n return _this._liveRecordArrays[modelName].destroy();\n });\n\n this._adapterPopulatedRecordArrays.forEach(function (entry) {\n return entry.destroy();\n });\n\n this.isDestroyed = true;\n };\n\n _proto.destroy = function destroy() {\n this.isDestroying = true;\n emberRun$1.schedule('actions', this, this.willDestroy);\n };\n\n return RecordArrayManager;\n }();\n\n var removeFromArray = function removeFromArray(array, item) {\n var index = array.indexOf(item);\n\n if (index !== -1) {\n array.splice(index, 1);\n return true;\n }\n\n return false;\n };\n\n var updateLiveRecordArray = function updateLiveRecordArray(store, recordArray, identifiers) {\n var identifiersToAdd = [];\n var identifiersToRemove = [];\n\n for (var i = 0; i < identifiers.length; i++) {\n var identifier = identifiers[i];\n var shouldInclude = shouldIncludeInRecordArrays(store, identifier);\n var recordArrays = recordArraysForIdentifier(identifier);\n\n if (shouldInclude) {\n if (!recordArrays.has(recordArray)) {\n identifiersToAdd.push(identifier);\n recordArrays.add(recordArray);\n }\n }\n\n if (!shouldInclude) {\n identifiersToRemove.push(identifier);\n recordArrays.delete(recordArray);\n }\n }\n\n if (identifiersToAdd.length > 0) {\n pushIdentifiers(recordArray, identifiersToAdd, internalModelFactoryFor(store));\n }\n\n if (identifiersToRemove.length > 0) {\n removeIdentifiers(recordArray, identifiersToRemove, internalModelFactoryFor(store));\n }\n };\n\n var pushIdentifiers = function pushIdentifiers(recordArray, identifiers, cache) {\n if ( !recordArray._pushIdentifiers) {\n // deprecate('not allowed to use this intimate api any more');\n recordArray._pushInternalModels(identifiers.map(function (i) {\n return peekIMCache(cache, i);\n }));\n } else {\n recordArray._pushIdentifiers(identifiers);\n }\n };\n\n var removeIdentifiers = function removeIdentifiers(recordArray, identifiers, cache) {\n if ( !recordArray._removeIdentifiers) {\n // deprecate('not allowed to use this intimate api any more');\n recordArray._removeInternalModels(identifiers.map(function (i) {\n return peekIMCache(cache, i);\n }));\n } else {\n recordArray._removeIdentifiers(identifiers);\n }\n };\n\n var removeFromAdapterPopulatedRecordArrays = function removeFromAdapterPopulatedRecordArrays(store, identifiers) {\n for (var i = 0; i < identifiers.length; i++) {\n removeFromAll(store, identifiers[i]);\n }\n };\n\n var removeFromAll = function removeFromAll(store, identifier) {\n identifier = getIdentifier(identifier);\n var recordArrays = recordArraysForIdentifier(identifier);\n var cache = internalModelFactoryFor(store);\n recordArrays.forEach(function (recordArray) {\n removeIdentifiers(recordArray, [identifier], cache);\n });\n recordArrays.clear();\n };\n\n function _defineProperties$3(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\n function _createClass$3(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$3(Constructor.prototype, protoProps); if (staticProps) _defineProperties$3(Constructor, staticProps); return Constructor; }\n\n function isResourceIdentiferWithRelatedLinks(value) {\n return value && value.links && value.links.related;\n }\n\n var REFERENCE_CACHE = new WeakMap();\n function internalModelForReference(reference) {\n return internalModelFactoryFor(reference.store).peek(REFERENCE_CACHE.get(reference));\n }\n /**\n This is the baseClass for the different References\n like RecordReference/HasManyReference/BelongsToReference\n\n @class Reference\n */\n\n var Reference = /*#__PURE__*/function () {\n function Reference(store, identifier) {\n this.store = store;\n REFERENCE_CACHE.set(this, identifier);\n }\n\n var _proto = Reference.prototype;\n\n _proto._resource = function _resource() {}\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 @return {String} The name of the remote type. This should either be \"link\" or \"ids\"\n */\n ;\n\n _proto.remoteType = function remoteType() {\n var value = this._resource();\n\n if (isResourceIdentiferWithRelatedLinks(value)) {\n return 'link';\n }\n\n return 'id';\n }\n /**\n The link Ember Data will use to fetch or reload this belongs-to\n 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: '/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 @return {String} The link Ember Data will use to fetch or reload this belongs-to relationship.\n */\n ;\n\n _proto.link = function link() {\n var link;\n\n var resource = this._resource();\n\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\n return link || null;\n };\n\n _proto.links = function links() {\n var resource = this._resource();\n\n return resource && resource.links ? resource.links : null;\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 meta: {\n lastUpdated: 1458014400000\n }\n }\n }\n }\n }\n });\n let userRef = blog.belongsTo('user');\n userRef.meta() // { lastUpdated: 1458014400000 }\n ```\n @method meta\n @return {Object} The meta information for the belongs-to relationship.\n */\n ;\n\n _proto.meta = function meta() {\n var meta = null;\n\n var resource = this._resource();\n\n if (resource && resource.meta && typeof resource.meta === 'object') {\n meta = resource.meta;\n }\n\n return meta;\n };\n\n _createClass$3(Reference, [{\n key: \"recordData\",\n get: function get() {\n return this.store.recordDataFor(REFERENCE_CACHE.get(this), false);\n }\n }]);\n\n return Reference;\n }();\n\n {\n Object.defineProperty(Reference.prototype, 'internalModel', {\n get: function get() {\n ( Ember.deprecate('Accessing the internalModel property of Reference is deprecated', false, {\n id: 'ember-data:reference-internal-model',\n until: '3.21'\n }));\n return REFERENCE_CACHE.get(this);\n }\n });\n }\n\n function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }\n\n function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }\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 @extends Reference\n */\n\n var BelongsToReference = /*#__PURE__*/function (_Reference) {\n _inheritsLoose(BelongsToReference, _Reference);\n\n function BelongsToReference(store, parentIMOrIdentifier, belongsToRelationship, key) {\n var _this;\n\n _this = _Reference.call(this, store, parentIMOrIdentifier) || this;\n _this.key = key;\n _this.belongsToRelationship = belongsToRelationship;\n _this.type = belongsToRelationship.relationshipMeta.type;\n _this.parent = internalModelFactoryFor(store).peek(parentIMOrIdentifier).recordReference;\n _this.parentIdentifier = parentIMOrIdentifier; // TODO inverse\n\n return _this;\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 @return {String} The id of the record in this belongsTo relationship.\n */\n\n\n var _proto = BelongsToReference.prototype;\n\n _proto.id = function id() {\n var id = null;\n\n var resource = this._resource();\n\n if (resource && resource.data) {\n id = resource.data.id;\n }\n\n return id;\n };\n\n _proto._resource = function _resource() {\n return this.recordData.getBelongsTo(this.key);\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 @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 ;\n\n _proto.push = function push(objectOrPromise) {\n var _this2 = this;\n\n // TODO deprecate thenable support\n return Ember.RSVP.resolve(objectOrPromise).then(function (data) {\n var record;\n\n if ( peekRecordIdentifier(data)) {\n ( Ember.deprecate('Pushing a record into a BelongsToReference is deprecated', false, {\n id: 'ember-data:belongs-to-reference-push-record',\n until: '4.0'\n }));\n record = data;\n } else {\n record = _this2.store.push(data);\n }\n\n Debug.assertPolymorphicType(internalModelForReference(_this2), _this2.belongsToRelationship.relationshipMeta, record._internalModel, _this2.store); //TODO Igor cleanup, maybe move to relationship push\n\n _this2.belongsToRelationship.setCanonicalRecordData(recordDataFor(record));\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 @return {Model} the record in this relationship\n */\n ;\n\n _proto.value = function value() {\n var resource = this._resource();\n\n if (resource && resource.data) {\n var inverseInternalModel = this.store._internalModelForResource(resource.data);\n\n if (inverseInternalModel && inverseInternalModel.isLoaded()) {\n return inverseInternalModel.getRecord();\n }\n }\n\n return null;\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 @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 ;\n\n _proto.load = function load(options) {\n var parentInternalModel = internalModelFactoryFor(this.store).peek(this.parentIdentifier);\n return parentInternalModel.getBelongsTo(this.key, options);\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 @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 ;\n\n _proto.reload = function reload(options) {\n var _this3 = this;\n\n var parentInternalModel = internalModelFactoryFor(this.store).peek(this.parentIdentifier);\n return parentInternalModel.reloadBelongsTo(this.key, options).then(function (internalModel) {\n return _this3.value();\n });\n };\n\n return BelongsToReference;\n }(Reference);\n\n function _inheritsLoose$1(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf$1(subClass, superClass); }\n\n function _setPrototypeOf$1(o, p) { _setPrototypeOf$1 = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$1(o, p); }\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 @extends Reference\n */\n\n var HasManyReference = /*#__PURE__*/function (_Reference) {\n _inheritsLoose$1(HasManyReference, _Reference);\n\n function HasManyReference(store, parentIMOrIdentifier, hasManyRelationship, key) {\n var _this;\n\n _this = _Reference.call(this, store, parentIMOrIdentifier) || this;\n _this.key = key;\n _this.hasManyRelationship = hasManyRelationship;\n _this.type = hasManyRelationship.relationshipMeta.type;\n _this.parent = internalModelFactoryFor(store).peek(parentIMOrIdentifier).recordReference; // TODO inverse\n\n return _this;\n }\n\n var _proto = HasManyReference.prototype;\n\n _proto._resource = function _resource() {\n return this.recordData.getHasMany(this.key);\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 @return {String} The name of the remote type. This should either be `link` or `ids`\n */\n ;\n\n _proto.remoteType = function remoteType() {\n var value = this._resource();\n\n if (value && value.links && value.links.related) {\n return 'link';\n }\n\n return 'ids';\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 @return {Array} The ids in this has-many relationship\n */\n ;\n\n _proto.ids = function ids() {\n var resource = this._resource();\n\n var ids = [];\n\n if (resource.data) {\n ids = resource.data.map(function (data) {\n return data.id;\n });\n }\n\n return ids;\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 @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 ;\n\n _proto.push = function push(objectOrPromise) {\n var _this2 = this;\n\n return Ember.RSVP.resolve(objectOrPromise).then(function (payload) {\n var array = payload;\n\n if (typeof payload === 'object' && payload.data) {\n array = payload.data;\n }\n\n var internalModel = internalModelForReference(_this2);\n var internalModels = array.map(function (obj) {\n var record = _this2.store.push(obj);\n\n {\n var relationshipMeta = _this2.hasManyRelationship.relationshipMeta;\n Debug.assertPolymorphicType(internalModel, relationshipMeta, record._internalModel, _this2.store);\n }\n\n return recordDataFor(record);\n });\n\n _this2.hasManyRelationship.computeChanges(internalModels);\n\n return internalModel.getHasMany(_this2.hasManyRelationship.key); // TODO IGOR it seems wrong that we were returning the many array here\n //return this.hasManyRelationship.manyArray;\n });\n };\n\n _proto._isLoaded = function _isLoaded() {\n var _this3 = this;\n\n var hasRelationshipDataProperty = this.hasManyRelationship.hasAnyRelationshipData;\n\n if (!hasRelationshipDataProperty) {\n return false;\n }\n\n var members = this.hasManyRelationship.members.toArray(); //TODO Igor cleanup\n\n return members.every(function (recordData) {\n var internalModel = _this3.store._internalModelForResource(recordData.getResourceIdentifier());\n\n return internalModel.isLoaded() === true;\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 @return {ManyArray}\n */\n ;\n\n _proto.value = function value() {\n var internalModel = internalModelForReference(this);\n\n if (this._isLoaded()) {\n return internalModel.getManyArray(this.key);\n }\n\n return null;\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 @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 ;\n\n _proto.load = function load(options) {\n var internalModel = internalModelForReference(this);\n return internalModel.getHasMany(this.key, options);\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 @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 ;\n\n _proto.reload = function reload(options) {\n var internalModel = internalModelForReference(this);\n return internalModel.reloadHasMany(this.key, options);\n };\n\n return HasManyReference;\n }(Reference);\n\n function _defineProperties$4(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\n function _createClass$4(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$4(Constructor.prototype, protoProps); if (staticProps) _defineProperties$4(Constructor, staticProps); return Constructor; }\n\n function _inheritsLoose$2(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf$2(subClass, superClass); }\n\n function _setPrototypeOf$2(o, p) { _setPrototypeOf$2 = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$2(o, p); }\n\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 @extends Reference\n */\n var RecordReference = /*#__PURE__*/function (_Reference) {\n _inheritsLoose$2(RecordReference, _Reference);\n\n function RecordReference() {\n return _Reference.apply(this, arguments) || this;\n }\n\n var _proto = RecordReference.prototype;\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 @return {String} The id of the record.\n */\n _proto.id = function id() {\n return this._id;\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 @return {String} The identifier of the record.\n */\n ;\n\n _proto.identifier = function identifier() {\n return REFERENCE_CACHE.get(this);\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 @return {String} 'identity'\n */\n ;\n\n _proto.remoteType = function remoteType() {\n return 'identity';\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 @param objectOrPromise a JSON:API ResourceDocument or a promise resolving to one\n @return a promise for the value (record or relationship)\n */\n ;\n\n _proto.push = function push(objectOrPromise) {\n var _this = this;\n\n return Ember.RSVP.resolve(objectOrPromise).then(function (data) {\n return _this.store.push(data);\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 @return {Model} the record for this RecordReference\n */\n ;\n\n _proto.value = function value() {\n if (this._id !== null) {\n var internalModel = internalModelForReference(this);\n\n if (internalModel && internalModel.isLoaded()) {\n return internalModel.getRecord();\n }\n }\n\n return null;\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 @return {Promise} the record for this RecordReference\n */\n ;\n\n _proto.load = function load() {\n if (this._id !== null) {\n return this.store.findRecord(this.type, this._id);\n }\n\n throw new Error(\"Unable to fetch record of type \" + this.type + \" without an id\");\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 @return {Promise} the record for this RecordReference\n */\n ;\n\n _proto.reload = function reload() {\n if (this._id !== null) {\n return this.store.findRecord(this.type, this._id, {\n reload: true\n });\n }\n\n throw new Error(\"Unable to fetch record of type \" + this.type + \" without an id\");\n };\n\n _createClass$4(RecordReference, [{\n key: \"type\",\n get: function get() {\n return this.identifier().type;\n }\n }, {\n key: \"_id\",\n get: function get() {\n var identifier = this.identifier();\n\n if (identifier) {\n return identifier.id;\n }\n\n return null;\n }\n }]);\n\n return RecordReference;\n }(Reference);\n\n /**\n @module @ember-data/store\n */\n\n /*\n This file encapsulates the various states that a record can transition\n through during its lifecycle.\n */\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 */\n function _didSetProperty(internalModel, context) {\n if (context.isDirty) {\n internalModel.send('becomeDirty');\n } else {\n internalModel.send('propertyWasReset');\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 // 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\n\n var DirtyState = {\n initialState: 'uncommitted',\n // FLAGS\n isDirty: true,\n // SUBSTATES\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: _didSetProperty,\n //TODO(Igor) reloading now triggers a\n //loadingData event, though it seems fine?\n loadingData: function loadingData() {},\n propertyWasReset: function propertyWasReset(internalModel, name) {\n if (!internalModel.hasChangedAttributes()) {\n internalModel.send('rolledBack');\n }\n },\n pushedData: function pushedData(internalModel) {\n if (!internalModel.hasChangedAttributes()) {\n internalModel.transitionTo('loaded.saved');\n }\n },\n becomeDirty: function becomeDirty() {},\n willCommit: function willCommit(internalModel) {\n internalModel.transitionTo('inFlight');\n },\n reloadRecord: function reloadRecord(internalModel, _ref) {\n var resolve = _ref.resolve,\n options = _ref.options;\n resolve(internalModel.store._reloadRecord(internalModel, options));\n },\n rolledBack: function rolledBack(internalModel) {\n internalModel.transitionTo('loaded.saved');\n internalModel.triggerLater('rolledBack');\n },\n becameInvalid: function becameInvalid(internalModel) {\n internalModel.transitionTo('invalid');\n },\n rollback: function 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: _didSetProperty,\n becomeDirty: function becomeDirty() {},\n pushedData: function pushedData() {},\n unloadRecord: assertAgainstUnloadRecord,\n // TODO: More robust semantics around save-while-in-flight\n willCommit: function willCommit() {},\n didCommit: function didCommit(internalModel) {\n internalModel.transitionTo('saved');\n internalModel.send('invokeLifecycleCallbacks', this.dirtyType);\n },\n rolledBack: function rolledBack(internalModel) {\n internalModel.triggerLater('rolledBack');\n },\n becameInvalid: function becameInvalid(internalModel) {\n internalModel.transitionTo('invalid');\n internalModel.send('invokeLifecycleCallbacks');\n },\n becameError: function 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: function deleteRecord(internalModel) {\n internalModel.transitionTo('deleted.uncommitted');\n },\n didSetProperty: function didSetProperty(internalModel, context) {\n internalModel.removeErrorMessageFromAttribute(context.name);\n\n _didSetProperty(internalModel, context);\n\n if (!internalModel.hasErrors()) {\n this.becameValid(internalModel);\n }\n },\n becameInvalid: function becameInvalid() {},\n becomeDirty: function becomeDirty() {},\n pushedData: function pushedData() {},\n willCommit: function willCommit(internalModel) {\n internalModel.clearErrorMessages();\n internalModel.transitionTo('inFlight');\n },\n rolledBack: function rolledBack(internalModel) {\n internalModel.clearErrorMessages();\n internalModel.transitionTo('loaded.saved');\n internalModel.triggerLater('ready');\n },\n becameValid: function becameValid(internalModel) {\n internalModel.transitionTo('uncommitted');\n },\n invokeLifecycleCallbacks: function invokeLifecycleCallbacks(internalModel) {\n internalModel.triggerLater('becameInvalid', internalModel);\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 var clone = {};\n var value;\n\n for (var prop in object) {\n value = object[prop];\n\n if (value && typeof value === 'object') {\n clone[prop] = deepClone(value);\n } else {\n clone[prop] = value;\n }\n }\n\n return clone;\n }\n\n function mixin(original, hash) {\n for (var prop in hash) {\n original[prop] = hash[prop];\n }\n\n return original;\n }\n\n function dirtyState(options) {\n var newState = deepClone(DirtyState);\n return mixin(newState, options);\n }\n\n var createdState = dirtyState({\n dirtyType: 'created',\n // FLAGS\n isNew: true,\n setup: function setup(internalModel) {\n internalModel.updateRecordArrays();\n }\n });\n\n createdState.invalid.rolledBack = function (internalModel) {\n internalModel.transitionTo('deleted.saved');\n internalModel.triggerLater('rolledBack');\n };\n\n createdState.uncommitted.rolledBack = function (internalModel) {\n internalModel.transitionTo('deleted.saved');\n internalModel.triggerLater('rolledBack');\n };\n\n var updatedState = dirtyState({\n dirtyType: 'updated'\n });\n\n function createdStateDeleteRecord(internalModel) {\n internalModel.transitionTo('deleted.saved');\n internalModel.send('invokeLifecycleCallbacks');\n }\n\n createdState.uncommitted.deleteRecord = createdStateDeleteRecord;\n createdState.invalid.deleteRecord = createdStateDeleteRecord;\n\n createdState.uncommitted.rollback = function (internalModel) {\n DirtyState.uncommitted.rollback.apply(this, arguments);\n internalModel.transitionTo('deleted.saved');\n };\n\n createdState.uncommitted.pushedData = function (internalModel) {\n internalModel.transitionTo('loaded.updated.uncommitted');\n internalModel.triggerLater('didLoad');\n };\n\n createdState.uncommitted.propertyWasReset = function () {};\n\n function assertAgainstUnloadRecord(internalModel) {\n ( Ember.assert('You can only unload a record which is not inFlight. `' + internalModel + '`', false));\n }\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\n updatedState.inFlight.unloadRecord = assertAgainstUnloadRecord;\n\n updatedState.uncommitted.deleteRecord = function (internalModel) {\n internalModel.transitionTo('deleted.uncommitted');\n };\n\n updatedState.invalid.rolledBack = function (internalModel) {\n internalModel.clearErrorMessages();\n internalModel.transitionTo('loaded.saved');\n internalModel.triggerLater('rolledBack');\n };\n\n var 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 // 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: function rolledBack() {},\n unloadRecord: function unloadRecord(internalModel) {},\n propertyWasReset: function propertyWasReset() {},\n // SUBSTATES\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: function loadingData(internalModel, promise) {\n {\n internalModel._promiseProxy = promise;\n }\n\n internalModel.transitionTo('loading');\n },\n loadedData: function loadedData(internalModel) {\n internalModel.transitionTo('loaded.created.uncommitted');\n internalModel.triggerLater('ready');\n },\n pushedData: function 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: function 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: function exit(internalModel) {\n internalModel._promiseProxy = null;\n },\n loadingData: function loadingData() {},\n // EVENTS\n pushedData: function pushedData(internalModel) {\n internalModel.transitionTo('loaded.saved');\n internalModel.triggerLater('didLoad');\n internalModel.triggerLater('ready'); //TODO this seems out of place here\n\n internalModel.didCleanError();\n },\n becameError: function becameError(internalModel) {\n internalModel.triggerLater('becameError', internalModel);\n },\n notFound: function 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: function loadingData() {},\n // SUBSTATES\n // If there are no local changes to a record, it remains\n // in the `saved` state.\n saved: {\n setup: function setup(internalModel) {\n if (internalModel.hasChangedAttributes()) {\n internalModel.adapterDidDirty();\n }\n },\n // EVENTS\n didSetProperty: _didSetProperty,\n pushedData: function pushedData() {},\n becomeDirty: function becomeDirty(internalModel) {\n internalModel.transitionTo('updated.uncommitted');\n },\n willCommit: function willCommit(internalModel) {\n internalModel.transitionTo('updated.inFlight');\n },\n reloadRecord: function reloadRecord(internalModel, _ref2) {\n var resolve = _ref2.resolve,\n options = _ref2.options;\n\n {\n resolve(internalModel.store._reloadRecord(internalModel, options));\n }\n },\n deleteRecord: function deleteRecord(internalModel) {\n internalModel.transitionTo('deleted.uncommitted');\n },\n unloadRecord: function unloadRecord(internalModel) {},\n didCommit: function didCommit() {},\n // loaded.saved.notFound would be triggered by a failed\n // `reload()` on an unchanged record\n notFound: function 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: function setup(internalModel) {\n internalModel.updateRecordArrays();\n },\n // SUBSTATES\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 willCommit: function willCommit(internalModel) {\n internalModel.transitionTo('inFlight');\n },\n rollback: function rollback(internalModel) {\n internalModel.rollbackAttributes();\n internalModel.triggerLater('ready');\n },\n pushedData: function pushedData() {},\n becomeDirty: function becomeDirty() {},\n deleteRecord: function deleteRecord() {},\n rolledBack: function 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 unloadRecord: assertAgainstUnloadRecord,\n // TODO: More robust semantics around save-while-in-flight\n willCommit: function willCommit() {},\n didCommit: function didCommit(internalModel) {\n internalModel.transitionTo('saved');\n internalModel.send('invokeLifecycleCallbacks');\n },\n becameError: function becameError(internalModel) {\n internalModel.transitionTo('uncommitted');\n internalModel.triggerLater('becameError', internalModel);\n },\n becameInvalid: function 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: function setup(internalModel) {\n internalModel.removeFromInverseRelationships();\n },\n invokeLifecycleCallbacks: function invokeLifecycleCallbacks(internalModel) {\n internalModel.triggerLater('didDelete', internalModel);\n internalModel.triggerLater('didCommit', internalModel);\n },\n willCommit: function willCommit() {},\n didCommit: function didCommit() {},\n pushedData: function pushedData() {}\n },\n invalid: {\n isValid: false,\n didSetProperty: function didSetProperty(internalModel, context) {\n internalModel.removeErrorMessageFromAttribute(context.name);\n\n _didSetProperty(internalModel, context);\n\n if (!internalModel.hasErrors()) {\n this.becameValid(internalModel);\n }\n },\n becameInvalid: function becameInvalid() {},\n becomeDirty: function becomeDirty() {},\n deleteRecord: function deleteRecord() {},\n willCommit: function willCommit() {},\n rolledBack: function rolledBack(internalModel) {\n internalModel.clearErrorMessages();\n internalModel.transitionTo('loaded.saved');\n internalModel.triggerLater('ready');\n },\n becameValid: function becameValid(internalModel) {\n internalModel.transitionTo('uncommitted');\n }\n }\n },\n invokeLifecycleCallbacks: function invokeLifecycleCallbacks(internalModel, dirtyType) {\n if (dirtyType === 'created') {\n internalModel.triggerLater('didCreate', internalModel);\n } else {\n internalModel.triggerLater('didUpdate', internalModel);\n }\n\n internalModel.triggerLater('didCommit', internalModel);\n }\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\n for (var prop in object) {\n if (!Object.prototype.hasOwnProperty.call(object, prop) || prop === 'parentState' || prop === 'stateName') {\n continue;\n }\n\n if (typeof object[prop] === 'object') {\n object[prop] = wireState(object[prop], object, name + '.' + prop);\n }\n }\n\n return object;\n }\n\n var RootState$1 = wireState(RootState, null, 'root');\n\n function _defineProperties$5(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\n function _createClass$5(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$5(Constructor.prototype, protoProps); if (staticProps) _defineProperties$5(Constructor, staticProps); return Constructor; }\n\n /**\n @module @ember-data/store\n */\n // once the presentation logic is moved into the Model package we can make\n // eliminate these lossy and redundant helpers\n function relationshipsFor$1(instance) {\n var recordData = recordDataFor(instance);\n return recordData._relationships;\n }\n\n function relationshipStateFor$1(instance, propertyName) {\n return relationshipsFor$1(instance).get(propertyName);\n }\n\n var hasOwnProperty = Object.prototype.hasOwnProperty;\n var ManyArray;\n var PromiseBelongsTo;\n var PromiseManyArray;\n var _found = false;\n\n var _getModelPackage;\n\n {\n _getModelPackage = function _getModelPackage() {\n if (!_found) {\n var modelPackage = require('@ember-data/model/-private');\n\n ManyArray = modelPackage.ManyArray;\n PromiseBelongsTo = modelPackage.PromiseBelongsTo;\n PromiseManyArray = modelPackage.PromiseManyArray;\n\n if (ManyArray && PromiseBelongsTo && PromiseManyArray) {\n _found = true;\n }\n }\n\n return _found;\n };\n } // TODO this should be integrated with the code removal so we can use it together with the if condition\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 var TransitionChainMap = Object.create(null);\n\n var _extractPivotNameCache = Object.create(null);\n\n var _splitOnDotCache = Object.create(null);\n\n function splitOnDot(name) {\n return _splitOnDotCache[name] || (_splitOnDotCache[name] = name.split('.'));\n }\n\n function extractPivotName(name) {\n return _extractPivotNameCache[name] || (_extractPivotNameCache[name] = splitOnDot(name)[0]);\n }\n /*\n `InternalModel` is the Model class that we use internally inside Ember Data to represent models.\n Internal ED methods should only deal with `InternalModel` objects. It is a fast, plain Javascript class.\n\n We expose `Model` to application code, by materializing a `Model` from `InternalModel` lazily, as\n a performance optimization.\n\n `InternalModel` should never be exposed to application code. At the boundaries of the system, in places\n like `find`, `push`, etc. we convert between Models and InternalModels.\n\n We need to make sure that the properties from `InternalModel` are correctly exposed/proxied on `Model`\n if they are needed.\n\n @private\n @class InternalModel\n */\n\n\n var InternalModel = /*#__PURE__*/function () {\n // Not typed yet\n // The previous ManyArrays for this relationship which will be destroyed when\n // we create a new ManyArray, but in the interim the retained version will be\n // updated if inverse internal models are unloaded.\n function InternalModel(store, identifier) {\n this._id = void 0;\n this._tag = 0;\n this.modelName = void 0;\n this.clientId = void 0;\n this.__recordData = void 0;\n this._isDestroyed = void 0;\n this.isError = void 0;\n this._pendingRecordArrayManagerFlush = void 0;\n this._isDematerializing = void 0;\n this.isReloading = void 0;\n this._doNotDestroy = void 0;\n this.isDestroying = void 0;\n this._promiseProxy = void 0;\n this._record = void 0;\n this._scheduledDestroy = void 0;\n this._modelClass = void 0;\n this.__deferredTriggers = void 0;\n this.__recordArrays = void 0;\n this._references = void 0;\n this._recordReference = void 0;\n this._manyArrayCache = Object.create(null);\n this._retainedManyArrayCache = Object.create(null);\n this._relationshipPromisesCache = Object.create(null);\n this._relationshipProxyCache = Object.create(null);\n this.currentState = void 0;\n this.error = void 0;\n this.store = store;\n this.identifier = identifier;\n\n {\n _getModelPackage();\n }\n\n this._id = identifier.id;\n this.modelName = identifier.type;\n this.clientId = identifier.lid;\n this.__recordData = null; // this ensure ordered set can quickly identify this as unique\n\n this[Ember.GUID_KEY] = identifier.lid;\n this._promiseProxy = null;\n this._record = null;\n this._isDestroyed = false;\n this.isError = false;\n this._pendingRecordArrayManagerFlush = false; // used by the recordArrayManager\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\n this._isDematerializing = false;\n this._scheduledDestroy = null;\n this.resetRecord(); // caches for lazy getters\n\n this._modelClass = null;\n this.__deferredTriggers = null;\n this.__recordArrays = null;\n this._references = null;\n this._recordReference = null;\n }\n\n var _proto = InternalModel.prototype;\n\n _proto.isHiddenFromRecordArrays = function 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 // eager checks to avoid instantiating record data if we are empty or loading\n if (this.isEmpty()) {\n return true;\n }\n\n var isRecordFullyDeleted;\n\n {\n isRecordFullyDeleted = this.currentState.stateName === 'root.deleted.saved';\n }\n\n return this._isDematerializing || this.hasScheduledDestroy() || this.isDestroyed || isRecordFullyDeleted;\n };\n\n _proto._isRecordFullyDeleted = function _isRecordFullyDeleted() {\n {\n // assert here\n return false;\n }\n };\n\n _proto.isRecordInUse = function isRecordInUse() {\n var record = this._record;\n return record && !(record.get('isDestroyed') || record.get('isDestroying'));\n };\n\n _proto.isEmpty = function isEmpty() {\n return this.currentState.isEmpty;\n };\n\n _proto.isLoading = function isLoading() {\n return this.currentState.isLoading;\n };\n\n _proto.isLoaded = function isLoaded() {\n return this.currentState.isLoaded;\n };\n\n _proto.hasDirtyAttributes = function hasDirtyAttributes() {\n return this.currentState.hasDirtyAttributes;\n };\n\n _proto.isSaving = function isSaving() {\n return this.currentState.isSaving;\n };\n\n _proto.isDeleted = function isDeleted() {\n {\n return this.currentState.isDeleted;\n }\n };\n\n _proto.isNew = function isNew() {\n {\n return this.currentState.isNew;\n }\n };\n\n _proto.isValid = function isValid() {\n {\n return this.currentState.isValid;\n }\n };\n\n _proto.dirtyType = function dirtyType() {\n return this.currentState.dirtyType;\n };\n\n _proto.getRecord = function getRecord(properties) {\n if (!this._record && !this._isDematerializing) {\n var _store = this.store;\n\n {\n {\n // lookupFactory should really return an object that creates\n // instances with the injections applied\n var createOptions = {\n store: _store,\n _internalModel: this,\n currentState: this.currentState\n };\n\n {\n createOptions.isError = this.isError;\n createOptions.adapterError = this.error;\n }\n\n if (properties !== undefined) {\n ( !(typeof properties === 'object' && properties !== null) && Ember.assert(\"You passed '\" + properties + \"' as properties for record creation instead of an object.\", typeof properties === 'object' && properties !== null));\n\n if ('id' in properties) {\n var id = coerceId(properties.id);\n\n if (id !== null) {\n this.setId(id);\n }\n } // convert relationship Records to RecordDatas before passing to RecordData\n\n\n var defs = _store._relationshipsDefinitionFor(this.modelName);\n\n if (defs !== null) {\n var keys = Object.keys(properties);\n var relationshipValue;\n\n for (var i = 0; i < keys.length; i++) {\n var prop = keys[i];\n var def = defs[prop];\n\n if (def !== undefined) {\n if (def.kind === 'hasMany') {\n {\n assertRecordsPassedToHasMany(properties[prop]);\n }\n\n relationshipValue = extractRecordDatasFromRecords(properties[prop]);\n } else {\n relationshipValue = extractRecordDataFromRecord(properties[prop]);\n }\n\n properties[prop] = relationshipValue;\n }\n }\n }\n }\n\n var additionalCreateOptions = this._recordData._initRecordCreateOptions(properties);\n\n Ember.assign(createOptions, additionalCreateOptions); // ensure that `getOwner(this)` works inside a model instance\n\n Ember.setOwner(createOptions, Ember.getOwner(_store));\n this._record = _store._modelFactoryFor(this.modelName).create(createOptions);\n setRecordIdentifier(this._record, this.identifier);\n }\n }\n\n this._triggerDeferredTriggers();\n }\n\n return this._record;\n };\n\n _proto.resetRecord = function resetRecord() {\n this._record = null;\n this.isReloading = false;\n this.error = null;\n this.currentState = RootState$1.empty;\n };\n\n _proto.dematerializeRecord = function dematerializeRecord() {\n var _this = this;\n\n this._isDematerializing = true; // 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\n this._doNotDestroy = false;\n\n if (this._record) {\n {\n this._record.destroy();\n }\n\n Object.keys(this._relationshipProxyCache).forEach(function (key) {\n if (_this._relationshipProxyCache[key].destroy) {\n _this._relationshipProxyCache[key].destroy();\n }\n\n delete _this._relationshipProxyCache[key];\n });\n Object.keys(this._manyArrayCache).forEach(function (key) {\n var manyArray = _this._retainedManyArrayCache[key] = _this._manyArrayCache[key];\n delete _this._manyArrayCache[key];\n\n if (manyArray && !manyArray._inverseIsAsync) {\n /*\n If the manyArray is for a sync relationship, we should clear it\n to preserve the semantics of client-side delete.\n It is likely in this case instead of retaining we should destroy\n - @runspired\n */\n manyArray.clear();\n }\n });\n } // move to an empty never-loaded state\n\n\n this.updateRecordArrays();\n\n this._recordData.unloadRecord();\n\n this.resetRecord();\n };\n\n _proto.deleteRecord = function deleteRecord() {\n\n this.send('deleteRecord');\n };\n\n _proto.save = function save(options) {\n var promiseLabel = 'DS: Model#save ' + this;\n var resolver = Ember.RSVP.defer(promiseLabel);\n\n {\n this.store.scheduleSave(this, resolver, options);\n return resolver.promise;\n }\n };\n\n _proto.startedReloading = function startedReloading() {\n this.isReloading = true;\n\n if (this.hasRecord) {\n Ember.set(this._record, 'isReloading', true);\n }\n };\n\n _proto.finishedReloading = function finishedReloading() {\n this.isReloading = false;\n\n if (this.hasRecord) {\n Ember.set(this._record, 'isReloading', false);\n }\n };\n\n _proto.reload = function reload(options) {\n {\n this.startedReloading();\n\n var _internalModel = this;\n\n var promiseLabel = 'DS: Model#reload of ' + this;\n return new Ember.RSVP.Promise(function (resolve) {\n _internalModel.send('reloadRecord', {\n resolve: resolve,\n options: options\n });\n }, promiseLabel).then(function () {\n _internalModel.didCleanError();\n\n return _internalModel;\n }, function (error) {\n _internalModel.didError(error);\n\n throw error;\n }, 'DS: Model#reload complete, update flags').finally(function () {\n _internalModel.finishedReloading();\n });\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 ;\n\n _proto.unloadRecord = function unloadRecord() {\n if (this.isDestroyed) {\n return;\n }\n\n this.send('unloadRecord');\n this.dematerializeRecord();\n\n if (this._scheduledDestroy === null) {\n this._scheduledDestroy = Ember.run.backburner.schedule('destroy', this, '_checkForOrphanedInternalModels');\n }\n };\n\n _proto.hasScheduledDestroy = function hasScheduledDestroy() {\n return !!this._scheduledDestroy;\n };\n\n _proto.cancelDestroy = function cancelDestroy() {\n ( !(!this.isDestroyed) && Ember.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 Ember.run.cancel(this._scheduledDestroy);\n this._scheduledDestroy = null;\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.find(‘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 ;\n\n _proto.destroySync = function destroySync() {\n if (this._isDematerializing) {\n this.cancelDestroy();\n }\n\n this._checkForOrphanedInternalModels();\n\n if (this.isDestroyed || this.isDestroying) {\n return;\n } // just in-case we are not one of the orphaned, we should still\n // still destroy ourselves\n\n\n this.destroy();\n };\n\n _proto._checkForOrphanedInternalModels = function _checkForOrphanedInternalModels() {\n this._isDematerializing = false;\n this._scheduledDestroy = null;\n\n if (this.isDestroyed) {\n return;\n }\n };\n\n _proto.eachRelationship = function eachRelationship(callback, binding) {\n return this.modelClass.eachRelationship(callback, binding);\n };\n\n _proto._findBelongsTo = function _findBelongsTo(key, resource, relationshipMeta, options) {\n var _this2 = this;\n\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(function (internalModel) {\n return handleCompletedRelationshipRequest(_this2, key, resource._relationship, internalModel, null);\n }, function (e) {\n return handleCompletedRelationshipRequest(_this2, key, resource._relationship, null, e);\n });\n };\n\n _proto.getBelongsTo = function getBelongsTo(key, options) {\n var resource = this._recordData.getBelongsTo(key);\n\n var identifier = resource && resource.data ? identifierCacheFor(this.store).getOrCreateRecordIdentifier(resource.data) : null;\n\n var relationshipMeta = this.store._relationshipMetaFor(this.modelName, null, key);\n\n var store = this.store;\n var parentInternalModel = this;\n var async = relationshipMeta.options.async;\n var isAsync = typeof async === 'undefined' ? true : async;\n var _belongsToState = {\n key: key,\n store: store,\n originatingInternalModel: this,\n modelName: relationshipMeta.type\n };\n\n if (isAsync) {\n var internalModel = identifier !== null ? store._internalModelForResource(identifier) : null;\n\n if (resource._relationship.hasFailedLoadAttempt) {\n return this._relationshipProxyCache[key];\n }\n\n var promise = this._findBelongsTo(key, resource, relationshipMeta, options);\n\n return this._updatePromiseProxyFor('belongsTo', key, {\n promise: promise,\n content: internalModel ? internalModel.getRecord() : null,\n _belongsToState: _belongsToState\n });\n } else {\n if (identifier === null) {\n return null;\n } else {\n var _internalModel2 = store._internalModelForResource(identifier);\n\n var toReturn = _internalModel2.getRecord();\n\n ( !(toReturn === null || !toReturn.get('isEmpty')) && Ember.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.get('isEmpty')));\n return toReturn;\n }\n }\n } // TODO Igor consider getting rid of initial state\n ;\n\n _proto.getManyArray = function getManyArray(key, isAsync) {\n if (isAsync === void 0) {\n isAsync = false;\n }\n\n var relationshipMeta = this.store._relationshipMetaFor(this.modelName, null, key);\n\n var jsonApi = this._recordData.getHasMany(key);\n\n var manyArray = this._manyArrayCache[key];\n ( !(!manyArray || !this._retainedManyArrayCache[key]) && Ember.assert(\"Error: relationship \" + this.modelName + \":\" + key + \" has both many array and retained many array\", !manyArray || !this._retainedManyArrayCache[key]));\n\n if (!manyArray) {\n var initialState = this.store._getHasManyByJsonApiResource(jsonApi); // TODO move this to a public api\n\n\n var inverseIsAsync = jsonApi._relationship ? jsonApi._relationship._inverseIsAsync() : false;\n manyArray = ManyArray.create({\n store: this.store,\n type: this.store.modelFor(relationshipMeta.type),\n recordData: this._recordData,\n meta: jsonApi.meta,\n links: jsonApi.links,\n key: key,\n isPolymorphic: relationshipMeta.options.polymorphic,\n initialState: initialState.slice(),\n _inverseIsAsync: inverseIsAsync,\n internalModel: this,\n isLoaded: !isAsync\n });\n this._manyArrayCache[key] = manyArray;\n }\n\n if (this._retainedManyArrayCache[key]) {\n this._retainedManyArrayCache[key].destroy();\n\n delete this._retainedManyArrayCache[key];\n }\n\n return manyArray;\n };\n\n _proto.fetchAsyncHasMany = function fetchAsyncHasMany(key, relationshipMeta, jsonApi, manyArray, options) {\n var _this3 = this;\n\n // TODO @runspired follow up if parent isNew then we should not be attempting load here\n var loadingPromise = this._relationshipPromisesCache[key];\n\n if (loadingPromise) {\n return loadingPromise;\n }\n\n loadingPromise = this.store._findHasManyByJsonApiResource(jsonApi, this, relationshipMeta, options).then(function () {\n // TODO why don't we do this in the store method\n manyArray.retrieveLatest();\n manyArray.set('isLoaded', true);\n return manyArray;\n }).then(function (manyArray) {\n return handleCompletedRelationshipRequest(_this3, key, jsonApi._relationship, manyArray, null);\n }, function (e) {\n return handleCompletedRelationshipRequest(_this3, key, jsonApi._relationship, null, e);\n });\n this._relationshipPromisesCache[key] = loadingPromise;\n return loadingPromise;\n };\n\n _proto.getHasMany = function getHasMany(key, options) {\n var jsonApi = this._recordData.getHasMany(key);\n\n var relationshipMeta = this.store._relationshipMetaFor(this.modelName, null, key);\n\n var async = relationshipMeta.options.async;\n var isAsync = typeof async === 'undefined' ? true : async;\n var manyArray = this.getManyArray(key, isAsync);\n\n if (isAsync) {\n if (jsonApi._relationship.hasFailedLoadAttempt) {\n return this._relationshipProxyCache[key];\n }\n\n var promise = this.fetchAsyncHasMany(key, relationshipMeta, jsonApi, manyArray, options);\n return this._updatePromiseProxyFor('hasMany', key, {\n promise: promise,\n content: manyArray\n });\n } else {\n ( !(!manyArray.anyUnloaded()) && Ember.assert(\"You looked up the '\" + key + \"' relationship on a '\" + this.type.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 })')\", !manyArray.anyUnloaded()));\n return manyArray;\n }\n };\n\n _proto._updatePromiseProxyFor = function _updatePromiseProxyFor(kind, key, args) {\n var promiseProxy = this._relationshipProxyCache[key];\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\n promiseProxy.set('promise', args.promise);\n } else {\n var klass = kind === 'hasMany' ? PromiseManyArray : PromiseBelongsTo; // this usage of `any` can be removed when `@types/ember_object` proxy allows `null` for content\n\n this._relationshipProxyCache[key] = klass.create(args);\n }\n\n return this._relationshipProxyCache[key];\n };\n\n _proto.reloadHasMany = function reloadHasMany(key, options) {\n var loadingPromise = this._relationshipPromisesCache[key];\n\n if (loadingPromise) {\n return loadingPromise;\n }\n\n var jsonApi = this._recordData.getHasMany(key); // TODO move this to a public api\n\n\n if (jsonApi._relationship) {\n jsonApi._relationship.setHasFailedLoadAttempt(false);\n\n jsonApi._relationship.setShouldForceReload(true);\n }\n\n var relationshipMeta = this.store._relationshipMetaFor(this.modelName, null, key);\n\n var manyArray = this.getManyArray(key);\n var promise = this.fetchAsyncHasMany(key, relationshipMeta, jsonApi, manyArray, options);\n\n if (this._relationshipProxyCache[key]) {\n return this._updatePromiseProxyFor('hasMany', key, {\n promise: promise\n });\n }\n\n return promise;\n };\n\n _proto.reloadBelongsTo = function reloadBelongsTo(key, options) {\n var loadingPromise = this._relationshipPromisesCache[key];\n\n if (loadingPromise) {\n return loadingPromise;\n }\n\n var resource = this._recordData.getBelongsTo(key); // TODO move this to a public api\n\n\n if (resource._relationship) {\n resource._relationship.setHasFailedLoadAttempt(false);\n\n resource._relationship.setShouldForceReload(true);\n }\n\n var relationshipMeta = this.store._relationshipMetaFor(this.modelName, null, key);\n\n var promise = this._findBelongsTo(key, resource, relationshipMeta, options);\n\n if (this._relationshipProxyCache[key]) {\n return this._updatePromiseProxyFor('belongsTo', key, {\n promise: promise\n });\n }\n\n return promise;\n };\n\n _proto.destroyFromRecordData = function destroyFromRecordData() {\n if (this._doNotDestroy) {\n this._doNotDestroy = false;\n return;\n }\n\n this.destroy();\n };\n\n _proto.destroy = function destroy() {\n var _this4 = this;\n\n ( !(!this._record || this._record.get('isDestroyed') || this._record.get('isDestroying')) && Ember.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 Object.keys(this._retainedManyArrayCache).forEach(function (key) {\n _this4._retainedManyArrayCache[key].destroy();\n\n delete _this4._retainedManyArrayCache[key];\n });\n internalModelFactoryFor(this.store).remove(this);\n this._isDestroyed = true;\n };\n\n _proto.eachAttribute = function eachAttribute(callback, binding) {\n return this.modelClass.eachAttribute(callback, binding);\n };\n\n _proto.inverseFor = function inverseFor(key) {\n return this.modelClass.inverseFor(key);\n };\n\n _proto.setupData = function setupData(data) {\n var changedKeys = this._recordData.pushData(data, this.hasRecord);\n\n if (this.hasRecord) {\n this._record._notifyProperties(changedKeys);\n }\n\n this.pushedData();\n };\n\n _proto.getAttributeValue = function getAttributeValue(key) {\n return this._recordData.getAttr(key);\n };\n\n _proto.setDirtyHasMany = function setDirtyHasMany(key, records) {\n assertRecordsPassedToHasMany(records);\n return this._recordData.setDirtyHasMany(key, extractRecordDatasFromRecords(records));\n };\n\n _proto.setDirtyBelongsTo = function setDirtyBelongsTo(key, value) {\n return this._recordData.setDirtyBelongsTo(key, extractRecordDataFromRecord(value));\n };\n\n _proto.setDirtyAttribute = function setDirtyAttribute(key, value) {\n if (this.isDeleted()) {\n {\n throw new Ember.Error(\"Attempted to set '\" + key + \"' to '\" + value + \"' on the deleted record \" + this);\n }\n }\n\n var currentValue = this.getAttributeValue(key);\n\n if (currentValue !== value) {\n this._recordData.setDirtyAttribute(key, value);\n\n var isDirty = this._recordData.isAttrDirty(key);\n\n this.send('didSetProperty', {\n name: key,\n isDirty: isDirty\n });\n }\n\n return value;\n };\n\n /*\n @method createSnapshot\n @private\n */\n _proto.createSnapshot = function createSnapshot(options) {\n return new Snapshot(options || {}, this.identifier, this.store);\n }\n /*\n @method loadingData\n @private\n @param {Promise} promise\n */\n ;\n\n _proto.loadingData = function loadingData(promise) {\n {\n this.send('loadingData', promise);\n }\n }\n /*\n @method loadedData\n @private\n */\n ;\n\n _proto.loadedData = function loadedData() {\n this.send('loadedData');\n }\n /*\n @method notFound\n @private\n */\n ;\n\n _proto.notFound = function notFound() {\n this.send('notFound');\n }\n /*\n @method pushedData\n @private\n */\n ;\n\n _proto.pushedData = function pushedData() {\n this.send('pushedData');\n };\n\n _proto.hasChangedAttributes = function hasChangedAttributes() {\n {\n if (this.isLoading() && !this.isReloading) {\n // no need to calculate changed attributes when calling `findRecord`\n return false;\n }\n }\n\n return this._recordData.hasChangedAttributes();\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 ;\n\n _proto.changedAttributes = function changedAttributes() {\n {\n if (this.isLoading() && !this.isReloading) {\n // no need to calculate changed attributes when calling `findRecord`\n return {};\n }\n }\n\n return this._recordData.changedAttributes();\n }\n /*\n @method adapterWillCommit\n @private\n */\n ;\n\n _proto.adapterWillCommit = function adapterWillCommit() {\n this._recordData.willCommit();\n\n this.send('willCommit');\n }\n /*\n @method adapterDidDirty\n @private\n */\n ;\n\n _proto.adapterDidDirty = function adapterDidDirty() {\n this.send('becomeDirty');\n }\n /*\n @method send\n @private\n @param {String} name\n @param {Object} context\n */\n ;\n\n _proto.send = function send(name, context) {\n var currentState = this.currentState;\n\n if (!currentState[name]) {\n this._unhandledEvent(currentState, name, context);\n }\n\n return currentState[name](this, context);\n };\n\n _proto.manyArrayRecordAdded = function manyArrayRecordAdded(key) {\n if (this.hasRecord) {\n {\n this._record.notifyHasManyAdded(key);\n }\n }\n };\n\n _proto.notifyHasManyChange = function notifyHasManyChange(key) {\n if (this.hasRecord) {\n {\n var manyArray = this._manyArrayCache[key];\n\n if (manyArray) {\n // TODO: this will \"resurrect\" previously unloaded records\n // see test '1:many async unload many side'\n // in `tests/integration/records/unload-test.js`\n // probably we don't want to retrieve latest eagerly when notifyhasmany changed\n // but rather lazily when someone actually asks for a manyarray\n //\n // that said, also not clear why we haven't moved this to retainedmanyarray so maybe that's the bit that's just not working\n manyArray.retrieveLatest();\n }\n }\n }\n };\n\n _proto.notifyBelongsToChange = function notifyBelongsToChange(key) {\n if (this.hasRecord) {\n {\n this._record.notifyBelongsToChange(key, this._record);\n }\n }\n };\n\n _proto.hasManyRemovalCheck = function hasManyRemovalCheck(key) {\n var manyArray = this._manyArrayCache[key] || this._retainedManyArrayCache[key];\n var didRemoveUnloadedModel = false;\n\n if (manyArray) {\n didRemoveUnloadedModel = manyArray.removeUnloadedInternalModel();\n\n if (this._manyArrayCache[key] && didRemoveUnloadedModel) {\n this._retainedManyArrayCache[key] = this._manyArrayCache[key];\n delete this._manyArrayCache[key];\n }\n }\n\n return didRemoveUnloadedModel;\n };\n\n _proto.notifyPropertyChange = function notifyPropertyChange(key) {\n if (this.hasRecord) {\n {\n this._record.notifyPropertyChange(key);\n }\n }\n\n {\n var manyArray = this._manyArrayCache[key] || this._retainedManyArrayCache[key];\n\n if (manyArray) {\n var didRemoveUnloadedModel = manyArray.removeUnloadedInternalModel();\n\n if (this._manyArrayCache[key] && didRemoveUnloadedModel) {\n this._retainedManyArrayCache[key] = this._manyArrayCache[key];\n delete this._manyArrayCache[key];\n }\n }\n }\n };\n\n _proto.notifyStateChange = function notifyStateChange(key) {\n ( Ember.assert('Cannot notify state change if Record Data State flag is not on', !!false));\n\n if (this.hasRecord) {\n {\n if (!key || key === 'isNew') {\n this.getRecord().notifyPropertyChange('isNew');\n }\n\n if (!key || key === 'isDeleted') {\n this.getRecord().notifyPropertyChange('isDeleted');\n }\n }\n }\n\n if (!key || key === 'isDeletionCommitted') {\n this.updateRecordArrays();\n }\n };\n\n _proto.didCreateRecord = function didCreateRecord() {\n this._recordData.clientDidCreate();\n };\n\n _proto.rollbackAttributes = function rollbackAttributes() {\n var dirtyKeys = this._recordData.rollbackAttributes();\n\n if (Ember.get(this, 'isError')) {\n this.didCleanError();\n }\n\n this.send('rolledBack');\n\n if (this._record && dirtyKeys && dirtyKeys.length > 0) {\n this._record._notifyProperties(dirtyKeys);\n }\n }\n /*\n @method transitionTo\n @private\n @param {String} name\n */\n ;\n\n _proto.transitionTo = function transitionTo(name) {\n // POSSIBLE TODO: Remove this code and replace with\n // always having direct reference to state objects\n var pivotName = extractPivotName(name);\n var state = this.currentState;\n var transitionMapId = state.stateName + \"->\" + name;\n\n do {\n if (state.exit) {\n state.exit(this);\n }\n\n state = state.parentState;\n } while (!state[pivotName]);\n\n var setups;\n var enters;\n var i;\n var l;\n var map = TransitionChainMap[transitionMapId];\n\n if (map) {\n setups = map.setups;\n enters = map.enters;\n state = map.state;\n } else {\n setups = [];\n enters = [];\n var path = splitOnDot(name);\n\n for (i = 0, l = path.length; i < l; i++) {\n state = state[path[i]];\n\n if (state.enter) {\n enters.push(state);\n }\n\n if (state.setup) {\n setups.push(state);\n }\n }\n\n TransitionChainMap[transitionMapId] = {\n setups: setups,\n enters: enters,\n state: state\n };\n }\n\n for (i = 0, l = enters.length; i < l; i++) {\n enters[i].enter(this);\n }\n\n this.currentState = state;\n\n if (this.hasRecord) {\n Ember.set(this._record, 'currentState', state);\n }\n\n for (i = 0, l = setups.length; i < l; i++) {\n setups[i].setup(this);\n }\n };\n\n _proto._unhandledEvent = function _unhandledEvent(state, name, context) {\n var errorMessage = 'Attempted to handle event `' + name + '` ';\n errorMessage += 'on ' + String(this) + ' while in state ';\n errorMessage += state.stateName + '. ';\n\n if (context !== undefined) {\n errorMessage += 'Called with ' + Ember.inspect(context) + '.';\n }\n\n throw new Ember.Error(errorMessage);\n };\n\n _proto.triggerLater = function triggerLater() {\n for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n args[_key] = arguments[_key];\n }\n\n if (this._deferredTriggers.push(args) !== 1) {\n return;\n }\n\n this.store._updateInternalModel(this);\n };\n\n _proto._triggerDeferredTriggers = function _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\n var triggers = this._deferredTriggers;\n var record = this._record;\n var trigger = record.trigger; // TODO Igor make nicer check\n\n if (trigger && typeof trigger === 'function') {\n for (var i = 0, l = triggers.length; i < l; i++) {\n var eventName = triggers[i];\n trigger.apply(record, eventName);\n }\n }\n\n triggers.length = 0;\n };\n\n _proto.removeFromInverseRelationships = function removeFromInverseRelationships(isNew) {\n if (isNew === void 0) {\n isNew = false;\n }\n\n this._recordData.removeFromInverseRelationships(isNew);\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 @method preloadData\n @private\n @param {Object} preload\n */\n ;\n\n _proto.preloadData = function preloadData(preload) {\n var _this5 = this;\n\n var jsonPayload = {}; //TODO(Igor) consider the polymorphic case\n\n Object.keys(preload).forEach(function (key) {\n var preloadValue = Ember.get(preload, key);\n\n var relationshipMeta = _this5.modelClass.metaForProperty(key);\n\n if (relationshipMeta.isRelationship) {\n if (!jsonPayload.relationships) {\n jsonPayload.relationships = {};\n }\n\n jsonPayload.relationships[key] = _this5._preloadRelationship(key, preloadValue);\n } else {\n if (!jsonPayload.attributes) {\n jsonPayload.attributes = {};\n }\n\n jsonPayload.attributes[key] = preloadValue;\n }\n });\n\n this._recordData.pushData(jsonPayload);\n };\n\n _proto._preloadRelationship = function _preloadRelationship(key, preloadValue) {\n var _this6 = this;\n\n var relationshipMeta = this.modelClass.metaForProperty(key);\n var modelClass = relationshipMeta.type;\n var data;\n\n if (relationshipMeta.kind === 'hasMany') {\n ( !(Array.isArray(preloadValue)) && Ember.assert('You need to pass in an array to set a hasMany property on a record', Array.isArray(preloadValue)));\n data = preloadValue.map(function (value) {\n return _this6._convertPreloadRelationshipToJSON(value, modelClass);\n });\n } else {\n data = this._convertPreloadRelationshipToJSON(preloadValue, modelClass);\n }\n\n return {\n data: data\n };\n };\n\n _proto._convertPreloadRelationshipToJSON = function _convertPreloadRelationshipToJSON(value, modelClass) {\n if (typeof value === 'string' || typeof value === 'number') {\n return {\n type: modelClass,\n id: value\n };\n }\n\n var internalModel;\n\n if (value._internalModel) {\n internalModel = value._internalModel;\n } else {\n internalModel = value;\n } // TODO IGOR DAVID assert if no id is present\n\n\n return {\n type: internalModel.modelName,\n id: internalModel.id\n };\n }\n /*\n Used to notify the store to update FilteredRecordArray membership.\n @method updateRecordArrays\n @private\n */\n ;\n\n _proto.updateRecordArrays = function updateRecordArrays() {\n this.store.recordArrayManager.recordDidChange(this.identifier);\n };\n\n _proto.setId = function setId(id) {\n var didChange = id !== this._id;\n this._id = id;\n Ember.set(this, '_tag', this._tag + 1);\n\n if (didChange && id !== null) {\n this.store.setRecordId(this.modelName, id, this.clientId); // internal set of ID to get it to RecordData from DS.Model\n\n if (this._recordData.__setId) {\n this._recordData.__setId(id);\n }\n }\n\n if (didChange && this.hasRecord) {\n {\n this.notifyPropertyChange('id');\n }\n }\n };\n\n _proto.didError = function didError(error) {\n {\n this.error = error;\n this.isError = true;\n\n if (this.hasRecord) {\n this._record.setProperties({\n isError: true,\n adapterError: error\n });\n }\n }\n };\n\n _proto.didCleanError = function didCleanError() {\n {\n this.error = null;\n this.isError = false;\n\n if (this.hasRecord) {\n this._record.setProperties({\n isError: false,\n adapterError: null\n });\n }\n }\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 @method adapterDidCommit\n */\n ;\n\n _proto.adapterDidCommit = function adapterDidCommit(data) {\n this.didCleanError();\n\n var changedKeys = this._recordData.didCommit(data);\n\n this.send('didCommit');\n this.updateRecordArrays();\n\n if (!data) {\n return;\n }\n\n {\n this._record._notifyProperties(changedKeys);\n }\n };\n\n _proto.addErrorMessageToAttribute = function addErrorMessageToAttribute(attribute, message) {\n Ember.get(this.getRecord(), 'errors')._add(attribute, message);\n };\n\n _proto.removeErrorMessageFromAttribute = function removeErrorMessageFromAttribute(attribute) {\n Ember.get(this.getRecord(), 'errors')._remove(attribute);\n };\n\n _proto.clearErrorMessages = function clearErrorMessages() {\n Ember.get(this.getRecord(), 'errors')._clear();\n };\n\n _proto.hasErrors = function hasErrors() {\n {\n var _errors = Ember.get(this.getRecord(), 'errors');\n\n return _errors.get('length') > 0;\n }\n } // FOR USE DURING COMMIT PROCESS\n\n /*\n @method adapterDidInvalidate\n @private\n */\n ;\n\n _proto.adapterDidInvalidate = function adapterDidInvalidate(parsedErrors, error) {\n {\n var _attribute;\n\n for (_attribute in parsedErrors) {\n if (hasOwnProperty.call(parsedErrors, _attribute)) {\n this.addErrorMessageToAttribute(_attribute, parsedErrors[_attribute]);\n }\n }\n\n this.send('becameInvalid');\n\n this._recordData.commitWasRejected();\n }\n };\n\n _proto.notifyErrorsChange = function notifyErrorsChange() {\n var invalidErrors;\n\n if (this._recordData.getErrors) {\n invalidErrors = this._recordData.getErrors(this.identifier) || [];\n } else {\n return;\n }\n\n this.notifyInvalidErrorsChange(invalidErrors);\n };\n\n _proto.notifyInvalidErrorsChange = function notifyInvalidErrorsChange(jsonApiErrors) {\n {\n this.getRecord().invalidErrorsChanged(jsonApiErrors);\n }\n }\n /*\n @method adapterDidError\n @private\n */\n ;\n\n _proto.adapterDidError = function adapterDidError(error) {\n this.send('becameError');\n this.didError(error);\n\n this._recordData.commitWasRejected();\n };\n\n _proto.toString = function toString() {\n return \"<\" + this.modelName + \":\" + this.id + \">\";\n };\n\n _proto.referenceFor = function referenceFor(kind, name) {\n var reference = this.references[name];\n\n if (!reference) {\n // TODO IGOR AND DAVID REFACTOR\n var relationship = relationshipStateFor$1(this, name);\n\n if ( kind) {\n var modelName = this.modelName;\n ( !(!!relationship) && Ember.assert(\"There is no \" + kind + \" relationship named '\" + name + \"' on a model of modelClass '\" + modelName + \"'\", !!relationship));\n var actualRelationshipKind = relationship.relationshipMeta.kind;\n ( !(actualRelationshipKind === kind) && Ember.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\n var relationshipKind = relationship.relationshipMeta.kind;\n var identifierOrInternalModel = this.identifier;\n\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\n this.references[name] = reference;\n }\n\n return reference;\n };\n\n _createClass$5(InternalModel, [{\n key: \"id\",\n get: function get() {\n return this.identifier.id;\n },\n set: function set(value) {\n if (value !== this._id) {\n var newIdentifier = {\n type: this.identifier.type,\n lid: this.identifier.lid,\n id: value\n };\n identifierCacheFor(this.store).updateRecordIdentifier(this.identifier, newIdentifier);\n Ember.set(this, '_tag', this._tag + 1); // TODO Show deprecation for private api\n }\n }\n }, {\n key: \"modelClass\",\n get: function get() {\n if (this.store.modelFor) {\n return this._modelClass || (this._modelClass = this.store.modelFor(this.modelName));\n }\n }\n }, {\n key: \"type\",\n get: function get() {\n return this.modelClass;\n }\n }, {\n key: \"recordReference\",\n get: function get() {\n if (this._recordReference === null) {\n this._recordReference = new RecordReference(this.store, this.identifier);\n }\n\n return this._recordReference;\n }\n }, {\n key: \"_recordData\",\n get: function get() {\n if (this.__recordData === null) {\n var recordData = this.store._createRecordData(this.identifier);\n\n this._recordData = recordData;\n return recordData;\n }\n\n return this.__recordData;\n },\n set: function set(newValue) {\n this.__recordData = newValue;\n }\n }, {\n key: \"references\",\n get: function get() {\n if (this._references === null) {\n this._references = Object.create(null);\n }\n\n return this._references;\n }\n }, {\n key: \"_deferredTriggers\",\n get: function get() {\n if (this.__deferredTriggers === null) {\n this.__deferredTriggers = [];\n }\n\n return this.__deferredTriggers;\n }\n }, {\n key: \"isDestroyed\",\n get: function get() {\n return this._isDestroyed;\n }\n }, {\n key: \"hasRecord\",\n get: function get() {\n return !!this._record;\n }\n }]);\n\n return InternalModel;\n }(); // in production code, this is only accesssed in `record-array-manager`\n\n {\n Object.defineProperty(InternalModel.prototype, '_recordArrays', {\n get: function get() {\n return recordArraysForIdentifier(this.identifier);\n }\n });\n }\n\n function handleCompletedRelationshipRequest(internalModel, key, relationship, value, error) {\n delete internalModel._relationshipPromisesCache[key];\n relationship.setShouldForceReload(false);\n\n if (error) {\n relationship.setHasFailedLoadAttempt(true);\n var proxy = internalModel._relationshipProxyCache[key]; // 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\n if (proxy && relationship.kind === 'belongsTo') {\n if (proxy.content && proxy.content.isDestroying) {\n proxy.set('content', null);\n }\n }\n\n throw error;\n }\n\n relationship.setHasFailedLoadAttempt(false); // only set to not stale if no error is thrown\n\n relationship.setRelationshipIsStale(false);\n return value;\n }\n\n function assertRecordsPassedToHasMany(records) {\n // TODO only allow native arrays\n ( !(Array.isArray(records) || Ember.Array.detect(records)) && Ember.assert(\"You must pass an array of records to set a hasMany relationship\", Array.isArray(records) || Ember.Array.detect(records)));\n ( !(function () {\n return Ember.A(records).every(function (record) {\n return hasOwnProperty.call(record, '_internalModel') === true;\n });\n }()) && Ember.assert(\"All elements of a hasMany relationship must be instances of Model, you passed \" + Ember.inspect(records), function () {\n return Ember.A(records).every(function (record) {\n return hasOwnProperty.call(record, '_internalModel') === true;\n });\n }()));\n }\n function extractRecordDatasFromRecords(records) {\n return records.map(extractRecordDataFromRecord);\n }\n function extractRecordDataFromRecord(recordOrPromiseRecord) {\n if (!recordOrPromiseRecord) {\n return null;\n }\n\n if (recordOrPromiseRecord.then) {\n var content = recordOrPromiseRecord.get && recordOrPromiseRecord.get('content');\n ( !(content !== undefined) && Ember.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\n return recordDataFor(recordOrPromiseRecord);\n }\n\n function _defineProperties$6(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\n function _createClass$6(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$6(Constructor.prototype, protoProps); if (staticProps) _defineProperties$6(Constructor, staticProps); return Constructor; }\n\n var AvailableShims = new WeakMap();\n function getShimClass(store, modelName) {\n var shims = AvailableShims.get(store);\n\n if (shims === undefined) {\n shims = Object.create(null);\n AvailableShims.set(store, shims);\n }\n\n var shim = shims[modelName];\n\n if (shim === undefined) {\n shim = shims[modelName] = new ShimModelClass(store, modelName);\n }\n\n return shim;\n } // Mimics the static apis of DSModel\n\n var ShimModelClass = /*#__PURE__*/function () {\n // TODO Maybe expose the class here?\n function ShimModelClass(__store, modelName) {\n this.__store = __store;\n this.modelName = modelName;\n }\n\n var _proto = ShimModelClass.prototype;\n\n _proto.eachAttribute = function eachAttribute(callback, binding) {\n var attrDefs = this.__store._attributesDefinitionFor(this.modelName);\n\n Object.keys(attrDefs).forEach(function (key) {\n callback.call(binding, key, attrDefs[key]);\n });\n };\n\n _proto.eachRelationship = function eachRelationship(callback, binding) {\n var relationshipDefs = this.__store._relationshipsDefinitionFor(this.modelName);\n\n Object.keys(relationshipDefs).forEach(function (key) {\n callback.call(binding, key, relationshipDefs[key]);\n });\n };\n\n _proto.eachTransformedAttribute = function eachTransformedAttribute(callback, binding) {\n var relationshipDefs = this.__store._relationshipsDefinitionFor(this.modelName);\n\n Object.keys(relationshipDefs).forEach(function (key) {\n if (relationshipDefs[key].type) {\n callback.call(binding, key, relationshipDefs[key]);\n }\n });\n };\n\n _createClass$6(ShimModelClass, [{\n key: \"fields\",\n get: function get() {\n var attrs = this.__store._attributesDefinitionFor(this.modelName);\n\n var relationships = this.__store._relationshipsDefinitionFor(this.modelName);\n\n var fields = new Map();\n Object.keys(attrs).forEach(function (key) {\n return fields.set(key, 'attribute');\n });\n Object.keys(relationships).forEach(function (key) {\n return fields.set(key, relationships[key].kind);\n });\n return fields;\n }\n }, {\n key: \"attributes\",\n get: function get() {\n var attrs = this.__store._attributesDefinitionFor(this.modelName);\n\n return new Map(Object.entries(attrs));\n }\n }, {\n key: \"relationshipsByName\",\n get: function get() {\n var relationships = this.__store._relationshipsDefinitionFor(this.modelName);\n\n return new Map(Object.entries(relationships));\n }\n }]);\n\n return ShimModelClass;\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\n function _find(adapter, store, modelClass, id, internalModel, options) {\n\n var snapshot = internalModel.createSnapshot(options);\n var modelName = internalModel.modelName;\n var promise = Ember.RSVP.Promise.resolve().then(function () {\n return adapter.findRecord(store, modelClass, id, snapshot);\n });\n var label = \"DS: Handle Adapter#findRecord of '\" + modelName + \"' with id: '\" + id + \"'\";\n var identifier = internalModel.identifier;\n promise = guardDestroyedStore(promise, store, label);\n return promise.then(function (adapterPayload) {\n ( !(payloadIsNotBlank(adapterPayload)) && Ember.assert(\"You made a 'findRecord' request for a '\" + modelName + \"' with id '\" + id + \"', but the adapter's response did not have any data\", payloadIsNotBlank(adapterPayload)));\n var serializer = store.serializerFor(modelName);\n var payload = normalizeResponseHelper(serializer, store, modelClass, adapterPayload, id, 'findRecord');\n ( !(!Array.isArray(payload.data)) && Ember.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 ( Ember.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 })); // ensure that regardless of id returned we assign to the correct record\n\n payload.data.lid = identifier.lid;\n return store._push(payload);\n }, function (error) {\n internalModel.notFound();\n\n if (internalModel.isEmpty()) {\n internalModel.unloadRecord();\n }\n\n throw error;\n }, \"DS: Extract payload of '\" + modelName + \"'\");\n }\n function _findMany(adapter, store, modelName, ids, internalModels, optionsMap) {\n var snapshots = Ember.A(internalModels.map(function (internalModel) {\n return internalModel.createSnapshot(optionsMap.get(internalModel));\n }));\n var modelClass = store.modelFor(modelName); // `adapter.findMany` gets the modelClass still\n\n var promise = adapter.findMany(store, modelClass, ids, snapshots);\n var label = \"DS: Handle Adapter#findMany of '\" + modelName + \"'\";\n\n if (promise === undefined) {\n throw new Error('adapter.findMany returned undefined, this was very likely a mistake');\n }\n\n promise = guardDestroyedStore(promise, store, label);\n return promise.then(function (adapterPayload) {\n ( !(payloadIsNotBlank(adapterPayload)) && Ember.assert(\"You made a 'findMany' request for '\" + modelName + \"' records with ids '[\" + ids + \"]', but the adapter's response did not have any data\", payloadIsNotBlank(adapterPayload)));\n var serializer = store.serializerFor(modelName);\n var payload = normalizeResponseHelper(serializer, store, modelClass, adapterPayload, null, 'findMany');\n return store._push(payload);\n }, null, \"DS: Extract payload of \" + modelName);\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 } // 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\n\n function syncRelationshipDataFromLink(store, payload, parentInternalModel, relationship) {\n var _relationships;\n\n // ensure the right hand side (incoming payload) points to the parent record that\n // requested this relationship\n var relationshipData = iterateData(payload.data, function (data, index) {\n var id = data.id,\n type = data.type;\n ensureRelationshipIsSetToParent(data, parentInternalModel, store, relationship, index);\n return {\n id: id,\n type: type\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\n var parentPayload = {\n id: parentInternalModel.id,\n type: parentInternalModel.modelName,\n relationships: (_relationships = {}, _relationships[relationship.key] = {\n meta: payload.meta,\n links: payload.links,\n data: relationshipData\n }, _relationships)\n };\n\n if (!Array.isArray(payload.included)) {\n payload.included = [];\n }\n\n payload.included.push(parentPayload);\n return payload;\n }\n\n function ensureRelationshipIsSetToParent(payload, parentInternalModel, store, parentRelationship, index) {\n var id = payload.id,\n type = payload.type;\n\n if (!payload.relationships) {\n payload.relationships = {};\n }\n\n var relationships = payload.relationships;\n var inverse = getInverse(store, parentInternalModel, parentRelationship, type);\n\n if (inverse) {\n var inverseKey = inverse.inverseKey,\n kind = inverse.kind;\n var relationshipData = relationships[inverseKey] && relationships[inverseKey].data;\n\n if ( typeof relationshipData !== 'undefined' && !relationshipDataPointsToParent(relationshipData, parentInternalModel)) {\n var inspect = function inspect(thing) {\n return \"'\" + JSON.stringify(thing) + \"'\";\n };\n\n var quotedType = inspect(type);\n var quotedInverse = inspect(inverseKey);\n var expected = inspect({\n id: parentInternalModel.id,\n type: parentInternalModel.modelName\n });\n var expectedModel = parentInternalModel.modelName + \":\" + parentInternalModel.id;\n var got = inspect(relationshipData);\n var prefix = typeof index === 'number' ? \"data[\" + index + \"]\" : \"data\";\n var path = prefix + \".relationships.\" + inverseKey + \".data\";\n var other = relationshipData ? \"<\" + relationshipData.type + \":\" + relationshipData.id + \">\" : null;\n var relationshipFetched = expectedModel + \".\" + parentRelationship.kind + \"(\\\"\" + parentRelationship.name + \"\\\")\";\n var includedRecord = \"<\" + type + \":\" + id + \">\";\n var 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'); // this should eventually throw instead of deprecating.\n\n ( Ember.deprecate(message + '\\n', false, {\n id: 'mismatched-inverse-relationship-data-from-payload',\n until: '3.8'\n }));\n }\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\n function getInverse(store, parentInternalModel, parentRelationship, type) {\n return recordDataFindInverseRelationshipInfo(store, parentInternalModel, parentRelationship, type);\n }\n\n function recordDataFindInverseRelationshipInfo(_ref, parentInternalModel, parentRelationship, type) {\n var _storeWrapper = _ref._storeWrapper;\n var lhs_relationshipName = parentRelationship.name;\n var modelName = parentInternalModel.modelName;\n\n var inverseKey = _storeWrapper.inverseForRelationship(modelName, lhs_relationshipName);\n\n if (inverseKey) {\n var kind = _storeWrapper.relationshipsDefinitionFor(type)[inverseKey].meta.kind;\n\n return {\n inverseKey: inverseKey,\n kind: kind\n };\n }\n }\n\n function relationshipDataPointsToParent(relationshipData, internalModel) {\n if (relationshipData === null) {\n return false;\n }\n\n if (Array.isArray(relationshipData)) {\n if (relationshipData.length === 0) {\n return false;\n }\n\n for (var i = 0; i < relationshipData.length; i++) {\n var entry = relationshipData[i];\n\n if (validateRelationshipEntry(entry, internalModel)) {\n return true;\n }\n }\n } else {\n return validateRelationshipEntry(relationshipData, internalModel);\n }\n\n return false;\n }\n\n function fixRelationshipData(relationshipData, relationshipKind, _ref2) {\n var id = _ref2.id,\n modelName = _ref2.modelName;\n var parentRelationshipData = {\n id: id,\n type: modelName\n };\n var payload;\n\n if (relationshipKind === 'hasMany') {\n payload = relationshipData || [];\n payload.push(parentRelationshipData);\n } else {\n payload = relationshipData || {};\n Ember.assign(payload, parentRelationshipData);\n }\n\n return payload;\n }\n\n function validateRelationshipEntry(_ref3, _ref4) {\n var id = _ref3.id;\n var parentModelID = _ref4.id;\n return id && id.toString() === parentModelID;\n }\n\n function _findHasMany(adapter, store, internalModel, link, relationship, options) {\n var snapshot = internalModel.createSnapshot(options);\n var modelClass = store.modelFor(relationship.type);\n var useLink = !link || typeof link === 'string';\n var relatedLink = useLink ? link : link.href;\n var promise = adapter.findHasMany(store, snapshot, relatedLink, relationship);\n var 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(function (adapterPayload) {\n ( !(payloadIsNotBlank(adapterPayload)) && Ember.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 var serializer = store.serializerFor(relationship.type);\n var payload = normalizeResponseHelper(serializer, store, modelClass, adapterPayload, null, 'findHasMany');\n payload = syncRelationshipDataFromLink(store, payload, internalModel, relationship);\n\n var internalModelArray = store._push(payload);\n\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 var snapshot = internalModel.createSnapshot(options);\n var modelClass = store.modelFor(relationship.type);\n var useLink = !link || typeof link === 'string';\n var relatedLink = useLink ? link : link.href;\n var promise = adapter.findBelongsTo(store, snapshot, relatedLink, relationship);\n var 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(function (adapterPayload) {\n var serializer = store.serializerFor(relationship.type);\n var payload = normalizeResponseHelper(serializer, store, modelClass, adapterPayload, null, 'findBelongsTo');\n\n if (!payload.data) {\n return null;\n }\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 var modelClass = store.modelFor(modelName); // adapter.findAll depends on the class\n\n var recordArray = store.peekAll(modelName);\n\n var snapshotArray = recordArray._createSnapshot(options);\n\n var promise = Ember.RSVP.Promise.resolve().then(function () {\n return adapter.findAll(store, modelClass, null, snapshotArray);\n });\n var label = 'DS: Handle Adapter#findAll of ' + modelClass;\n promise = guardDestroyedStore(promise, store, label);\n return promise.then(function (adapterPayload) {\n ( !(payloadIsNotBlank(adapterPayload)) && Ember.assert(\"You made a 'findAll' request for '\" + modelName + \"' records, but the adapter's response did not have any data\", payloadIsNotBlank(adapterPayload)));\n var serializer = store.serializerFor(modelName);\n var payload = normalizeResponseHelper(serializer, store, modelClass, adapterPayload, null, 'findAll');\n\n store._push(payload);\n\n store._didUpdateAll(modelName);\n\n return recordArray;\n }, null, 'DS: Extract payload of findAll ${modelName}');\n }\n function _query(adapter, store, modelName, query, recordArray, options) {\n var modelClass = store.modelFor(modelName); // adapter.query needs the class\n\n recordArray = recordArray || store.recordArrayManager.createAdapterPopulatedRecordArray(modelName, query);\n var promise = Ember.RSVP.Promise.resolve().then(function () {\n return adapter.query(store, modelClass, query, recordArray, options);\n });\n var label = \"DS: Handle Adapter#query of \" + modelName;\n promise = guardDestroyedStore(promise, store, label);\n return promise.then(function (adapterPayload) {\n var serializer = store.serializerFor(modelName);\n var payload = normalizeResponseHelper(serializer, store, modelClass, adapterPayload, null, 'query');\n\n var internalModels = store._push(payload);\n\n ( !(Array.isArray(internalModels)) && Ember.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 var identifiers = internalModels.map(function (im) {\n return im.identifier;\n });\n\n if (recordArray) {\n recordArray._setIdentifiers(identifiers, payload);\n } else {\n recordArray = store.recordArrayManager.createAdapterPopulatedRecordArray(modelName, query, identifiers, payload);\n }\n\n return recordArray;\n }, null, \"DS: Extract payload of query \" + modelName);\n }\n function _queryRecord(adapter, store, modelName, query, options) {\n var modelClass = store.modelFor(modelName); // adapter.queryRecord needs the class\n\n var promise = Ember.RSVP.Promise.resolve().then(function () {\n return adapter.queryRecord(store, modelClass, query, options);\n });\n var label = \"DS: Handle Adapter#queryRecord of \" + modelName;\n promise = guardDestroyedStore(promise, store, label);\n return promise.then(function (adapterPayload) {\n var serializer = store.serializerFor(modelName);\n var payload = normalizeResponseHelper(serializer, store, modelClass, adapterPayload, null, 'queryRecord');\n ( !(!Array.isArray(payload.data)) && Ember.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 id: 'ds.store.queryRecord-array-response'\n }));\n return store._push(payload);\n }, null, \"DS: Extract payload of queryRecord \" + modelName);\n }\n\n /**\n @module @ember-data/store\n */\n\n /**\n * Use this brand to assign a string key to an interface\n * for mapping the interface to a tightly coupled internal\n * class implementation.\n *\n * This allows us to expose the interface publicly but\n * seamlessly upgrade these interfaces for our own use\n * internally when internal methods and properties are\n * needed.\n *\n * @internal\n */\n\n var BRAND_SYMBOL = symbol('DEBUG-ts-brand');\n\n /**\n @module @ember-data/store\n */\n\n /**\n * Casts a public interface to the matching internal class implementation\n *\n * @internal\n */\n function upgradeForInternal(external) {\n return external;\n }\n\n function _defineProperties$7(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\n function _createClass$7(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$7(Constructor.prototype, protoProps); if (staticProps) _defineProperties$7(Constructor, staticProps); return Constructor; }\n\n var RecordDataStoreWrapper = /*#__PURE__*/function () {\n function RecordDataStoreWrapper(_store) {\n this[BRAND_SYMBOL] = void 0;\n this._willUpdateManyArrays = void 0;\n this._pendingManyArrayUpdates = void 0;\n this._store = _store;\n this._willUpdateManyArrays = false;\n this._pendingManyArrayUpdates = [];\n }\n\n var _proto = RecordDataStoreWrapper.prototype;\n\n /**\n * Exists so that DefaultRecordData can check for model types\n * in DEBUG for relationships. Should be refactored away.\n *\n * @internal\n */\n _proto._hasModelFor = function _hasModelFor(type) {\n return this._store._hasModelFor(type);\n }\n /**\n * @internal\n */\n ;\n\n _proto._scheduleManyArrayUpdate = function _scheduleManyArrayUpdate(identifier, key) {\n var _this = this;\n\n var pending = this._pendingManyArrayUpdates = this._pendingManyArrayUpdates || [];\n pending.push(identifier, key);\n\n if (this._willUpdateManyArrays === true) {\n return;\n }\n\n this._willUpdateManyArrays = true;\n var backburner = this._store._backburner;\n backburner.join(function () {\n backburner.schedule('syncRelationships', _this, _this._flushPendingManyArrayUpdates);\n });\n };\n\n _proto.notifyErrorsChange = function notifyErrorsChange(type, id, lid) {\n var resource = constructResource(type, id, lid);\n var identifier = identifierCacheFor(this._store).getOrCreateRecordIdentifier(resource);\n var internalModel = internalModelFactoryFor(this._store).peek(identifier);\n\n if (internalModel) {\n internalModel.notifyErrorsChange();\n }\n };\n\n _proto._flushPendingManyArrayUpdates = function _flushPendingManyArrayUpdates() {\n if (this._willUpdateManyArrays === false) {\n return;\n }\n\n var pending = this._pendingManyArrayUpdates;\n this._pendingManyArrayUpdates = [];\n this._willUpdateManyArrays = false;\n var factory = internalModelFactoryFor(this._store);\n\n for (var i = 0; i < pending.length; i += 2) {\n var identifier = pending[i];\n var _key = pending[i + 1];\n var internalModel = factory.peek(identifier);\n\n if (internalModel) {\n internalModel.notifyHasManyChange(_key);\n }\n }\n };\n\n _proto.attributesDefinitionFor = function attributesDefinitionFor(type) {\n return this._store._attributesDefinitionFor(type);\n };\n\n _proto.relationshipsDefinitionFor = function relationshipsDefinitionFor(type) {\n return this._store._relationshipsDefinitionFor(type);\n };\n\n _proto.inverseForRelationship = function inverseForRelationship(type, key) {\n var modelClass = this._store.modelFor(type);\n\n var definition = upgradeForInternal(this.relationshipsDefinitionFor(type)[key]);\n\n {\n return definition._inverseKey(this._store, modelClass);\n }\n };\n\n _proto.inverseIsAsyncForRelationship = function inverseIsAsyncForRelationship(type, key) {\n var modelClass = this._store.modelFor(type);\n\n var definition = upgradeForInternal(this.relationshipsDefinitionFor(type)[key]);\n\n {\n return definition._inverseIsAsync(this._store, modelClass);\n }\n };\n\n _proto.notifyPropertyChange = function notifyPropertyChange(type, id, lid, key) {\n var resource = constructResource(type, id, lid);\n var identifier = identifierCacheFor(this._store).getOrCreateRecordIdentifier(resource);\n var internalModel = internalModelFactoryFor(this._store).peek(identifier);\n\n if (internalModel) {\n internalModel.notifyPropertyChange(key);\n }\n };\n\n _proto.notifyHasManyChange = function notifyHasManyChange(type, id, lid, key) {\n var resource = constructResource(type, id, lid);\n var identifier = identifierCacheFor(this._store).getOrCreateRecordIdentifier(resource);\n\n this._scheduleManyArrayUpdate(identifier, key);\n };\n\n _proto.notifyBelongsToChange = function notifyBelongsToChange(type, id, lid, key) {\n var resource = constructResource(type, id, lid);\n var identifier = identifierCacheFor(this._store).getOrCreateRecordIdentifier(resource);\n var internalModel = internalModelFactoryFor(this._store).peek(identifier);\n\n if (internalModel) {\n internalModel.notifyBelongsToChange(key);\n }\n };\n\n _proto.notifyStateChange = function notifyStateChange(type, id, lid, key) {\n var resource = constructResource(type, id, lid);\n var identifier = identifierCacheFor(this._store).getOrCreateRecordIdentifier(resource);\n var internalModel = internalModelFactoryFor(this._store).peek(identifier);\n\n if (internalModel) {\n internalModel.notifyStateChange(key);\n }\n };\n\n _proto.recordDataFor = function recordDataFor(type, id, lid) {\n var identifier;\n var isCreate = false;\n\n if (!id && !lid) {\n isCreate = true;\n identifier = {\n type: type\n };\n } else {\n var resource = constructResource(type, id, lid);\n identifier = identifierCacheFor(this._store).getOrCreateRecordIdentifier(resource);\n }\n\n return this._store.recordDataFor(identifier, isCreate);\n };\n\n _proto.setRecordId = function setRecordId(type, id, lid) {\n this._store.setRecordId(type, id, lid);\n };\n\n _proto.isRecordInUse = function isRecordInUse(type, id, lid) {\n var resource = constructResource(type, id, lid);\n var identifier = identifierCacheFor(this._store).getOrCreateRecordIdentifier(resource);\n var internalModel = internalModelFactoryFor(this._store).peek(identifier);\n\n if (!internalModel) {\n return false;\n }\n\n return internalModel.isRecordInUse();\n };\n\n _proto.disconnectRecord = function disconnectRecord(type, id, lid) {\n var resource = constructResource(type, id, lid);\n var identifier = identifierCacheFor(this._store).getOrCreateRecordIdentifier(resource);\n var internalModel = internalModelFactoryFor(this._store).peek(identifier);\n\n if (internalModel) {\n internalModel.destroyFromRecordData();\n }\n };\n\n _createClass$7(RecordDataStoreWrapper, [{\n key: \"identifierCache\",\n get: function get() {\n return identifierCacheFor(this._store);\n }\n }]);\n\n return RecordDataStoreWrapper;\n }();\n\n function _defineProperties$8(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\n function _createClass$8(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$8(Constructor.prototype, protoProps); if (staticProps) _defineProperties$8(Constructor, staticProps); return Constructor; }\n\n function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return self; }\n\n function _inheritsLoose$3(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf$3(subClass, superClass); }\n\n function _setPrototypeOf$3(o, p) { _setPrototypeOf$3 = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$3(o, p); }\n\n var _RecordData;\n\n var emberRun$2 = Ember.run.backburner;\n var ENV = Ember.ENV;\n\n var RECORD_REFERENCES = new WeakMap();\n\n function freeze$1(obj) {\n if (typeof Object.freeze === 'function') {\n return Object.freeze(obj);\n }\n\n return obj;\n }\n\n function deprecateTestRegistration(factoryType, factoryName) {\n ( Ember.deprecate(\"You looked up the \" + factoryType + \" \\\"\" + factoryName + \"\\\" but it was not found. Likely this means you are using a legacy ember-qunit moduleFor helper. Add \\\"needs: ['\" + factoryType + \":\" + factoryName + \"']\\\", \\\"integration: true\\\", or refactor to modern syntax to resolve this deprecation.\", false, {\n id: 'ember-data:-legacy-test-registrations',\n until: '3.17'\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](../classes/Store/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](../classes/Store/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](../classes/Store/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 @class Store\n @extends Ember.Service\n */\n\n\n var CoreStore = /*#__PURE__*/function (_Ember$Service) {\n _inheritsLoose$3(CoreStore, _Ember$Service);\n\n /**\n * EmberData specific backburner instance\n */\n\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 record save requests\n // used for coalescing relationship updates\n // used for coalescing internal model updates\n // used to keep track of all the find requests that need to be coalesced\n // DEBUG-only properties\n\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 @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 function CoreStore() {\n var _this;\n\n _this = _Ember$Service.apply(this, arguments) || this;\n _this._backburner = backburner;\n _this.recordArrayManager = new RecordArrayManager({\n store: _assertThisInitialized(_this)\n });\n _this._notificationManager = void 0;\n _this._adapterCache = Object.create(null);\n _this._serializerCache = Object.create(null);\n _this._storeWrapper = new RecordDataStoreWrapper(_assertThisInitialized(_this));\n _this._pendingSave = [];\n _this._updatedRelationships = [];\n _this._updatedInternalModels = [];\n _this._pendingFetch = new Map();\n _this._fetchManager = void 0;\n _this._schemaDefinitionService = void 0;\n _this._trackedAsyncRequests = void 0;\n _this.shouldAssertMethodCallsOnDestroyedStore = false;\n _this.shouldTrackAsyncRequests = false;\n _this.generateStackTracesForTrackedRequests = false;\n _this._trackAsyncRequestStart = void 0;\n _this._trackAsyncRequestEnd = void 0;\n _this.__asyncWaiter = void 0;\n\n {\n {\n // support for legacy moduleFor style unit tests\n // that did not include transforms in \"needs\"\n // or which were not set to integration:true\n // that were relying on ember-test-helpers\n // doing an auto-registration of the transform\n // or us doing one\n var Mapping = {\n date: 'DateTransform',\n boolean: 'BooleanTransform',\n number: 'NumberTransform',\n string: 'StringTransform'\n };\n var shouldWarn = false;\n var owner = Ember.getOwner(_assertThisInitialized(_this));\n Object.keys(Mapping).forEach(function (attributeType) {\n var transformFactory = owner.factoryFor(\"transform:\" + attributeType);\n\n if (!transformFactory) {\n // we don't deprecate this because the moduleFor style tests with the closed\n // resolver will be deprecated on their own. When that deprecation completes\n // we can drop this.\n var Transform = require$1(\"@ember-data/serializer/-private\")[Mapping[attributeType]];\n\n owner.register(\"transform:\" + attributeType, Transform);\n shouldWarn = true;\n }\n });\n\n if (shouldWarn) {\n ( Ember.deprecate(\"You are relying on the automatic registration of the transforms \\\"date\\\", \\\"number\\\", \\\"boolean\\\", and \\\"string\\\". Likely this means you are using a legacy ember-qunit moduleFor helper. Add \\\"needs: ['transform:date', 'transform:boolean', 'transform:number', 'transform:string']\\\", \\\"integration: true\\\", or refactor to modern syntax to resolve this deprecation.\", false, {\n id: 'ember-data:-legacy-test-registrations',\n until: '3.17'\n }));\n }\n }\n\n _this.shouldAssertMethodCallsOnDestroyedStore = _this.shouldAssertMethodCallsOnDestroyedStore || false;\n\n if (_this.shouldTrackAsyncRequests === undefined) {\n _this.shouldTrackAsyncRequests = false;\n }\n\n if (_this.generateStackTracesForTrackedRequests === undefined) {\n _this.generateStackTracesForTrackedRequests = false;\n }\n\n _this._trackedAsyncRequests = [];\n\n _this._trackAsyncRequestStart = function (label) {\n var trace = 'set `store.generateStackTracesForTrackedRequests = true;` to get a detailed trace for where this request originated';\n\n if (_this.generateStackTracesForTrackedRequests) {\n try {\n throw new Error(\"EmberData TrackedRequest: \" + label);\n } catch (e) {\n trace = e;\n }\n }\n\n var token = freeze$1({\n label: label,\n trace: trace\n });\n\n _this._trackedAsyncRequests.push(token);\n\n return token;\n };\n\n _this._trackAsyncRequestEnd = function (token) {\n var index = _this._trackedAsyncRequests.indexOf(token);\n\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\n _this._trackedAsyncRequests.splice(index, 1);\n };\n\n _this.__asyncWaiter = function () {\n var shouldTrack = _this.shouldTrackAsyncRequests;\n var tracked = _this._trackedAsyncRequests;\n var isSettled = tracked.length === 0;\n return shouldTrack !== true || isSettled;\n };\n\n Ember.Test.registerWaiter(_this.__asyncWaiter);\n }\n\n return _this;\n }\n\n var _proto = CoreStore.prototype;\n\n _proto.getRequestStateService = function getRequestStateService() {\n\n assertInDebug('RequestService is not available unless the feature flag is on and running on a canary build', false);\n };\n\n _proto._instantiateRecord = function _instantiateRecord(internalModel, modelName, recordData, identifier, properties) {\n\n assertInDebug('should not be here, custom model class ff error', false);\n };\n\n _proto._internalDeleteRecord = function _internalDeleteRecord(internalModel) {\n internalModel.deleteRecord();\n } // FeatureFlagged in the DSModelStore claas\n ;\n\n _proto._attributesDefinitionFor = function _attributesDefinitionFor(modelName, identifier) {\n if (identifier) {\n return this.getSchemaDefinitionService().attributesDefinitionFor(identifier);\n } else {\n return this.getSchemaDefinitionService().attributesDefinitionFor(modelName);\n }\n };\n\n _proto._relationshipsDefinitionFor = function _relationshipsDefinitionFor(modelName, identifier) {\n if (identifier) {\n return this.getSchemaDefinitionService().relationshipsDefinitionFor(identifier);\n } else {\n return this.getSchemaDefinitionService().relationshipsDefinitionFor(modelName);\n }\n };\n\n _proto.registerSchemaDefinitionService = function registerSchemaDefinitionService(schema) {\n this._schemaDefinitionService = schema;\n };\n\n _proto.getSchemaDefinitionService = function getSchemaDefinitionService() {\n\n assertInDebug('need to enable CUSTOM_MODEL_CLASS feature flag in order to access SchemaDefinitionService', false);\n } // TODO Double check this return value is correct\n ;\n\n _proto._relationshipMetaFor = function _relationshipMetaFor(modelName, id, key) {\n return this._relationshipsDefinitionFor(modelName)[key];\n };\n\n _proto.modelFor = function modelFor(modelName) {\n {\n assertDestroyedStoreOnly(this, 'modelFor');\n }\n\n return getShimClass(this, modelName);\n } // Feature Flagged in DSModelStore\n\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 @private\n */\n ;\n\n _proto._hasModelFor = function _hasModelFor(modelName) {\n ( !(Ember.isPresent(modelName)) && Ember.assert(\"You need to pass a model name to the store's hasModelFor method\", Ember.isPresent(modelName)));\n ( !(typeof modelName === 'string') && Ember.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 // . 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 @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 ;\n\n _proto.createRecord = function createRecord(modelName, inputProperties) {\n var _this2 = this;\n\n {\n assertDestroyingStore(this, 'createRecord');\n }\n\n ( !(Ember.isPresent(modelName)) && Ember.assert(\"You need to pass a model name to the store's createRecord method\", Ember.isPresent(modelName)));\n ( !(typeof modelName === 'string') && Ember.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\n return emberRun$2.join(function () {\n return _this2._backburner.join(function () {\n var normalizedModelName = normalizeModelName(modelName);\n var properties = Ember.assign({}, inputProperties); // 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 (Ember.isNone(properties.id)) {\n properties.id = _this2._generateId(normalizedModelName, properties);\n } // Coerce ID to a string\n\n\n properties.id = coerceId(properties.id);\n var factory = internalModelFactoryFor(_this2);\n var internalModel = factory.build({\n type: normalizedModelName,\n id: properties.id\n });\n internalModel.loadedData(); // TODO this exists just to proxy `isNew` to RecordData which is weird\n\n internalModel.didCreateRecord();\n return internalModel.getRecord(properties);\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 ;\n\n _proto._generateId = function _generateId(modelName, properties) {\n var adapter = this.adapterFor(modelName);\n\n if (adapter && adapter.generateIdForRecord) {\n return adapter.generateIdForRecord(this, modelName, properties);\n }\n\n return null;\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 @param {Model} record\n */\n ;\n\n _proto.deleteRecord = function deleteRecord(record) {\n {\n assertDestroyingStore(this, 'deleteRecord');\n }\n\n {\n record.deleteRecord();\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 @param {Model} record\n */\n ;\n\n _proto.unloadRecord = function unloadRecord(record) {\n {\n assertDestroyingStore(this, 'unloadRecord');\n }\n\n {\n record.unloadRecord();\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 ;\n\n _proto.find = function find(modelName, id, options) {\n {\n assertDestroyingStore(this, 'find');\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\n\n ( !(arguments.length !== 1) && Ember.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) && Ember.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) && Ember.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') && Ember.assert(\"You cannot pass '\" + id + \"' as id to the store's find method\", typeof id === 'string' || typeof id === 'number'));\n ( !(typeof id !== 'object') && Ember.assert(\"Calling store.find() with a query object is no longer supported. Use store.query() instead.\", typeof id !== 'object'));\n ( !(typeof modelName === 'string') && Ember.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 This method returns a record for a given type and id combination.\n The `findRecord` method will always resolve its promise with the same\n object for a given type and `id`.\n The `findRecord` method will always return a **promise** that will be\n resolved with the record.\n Example\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);\n }\n }\n ```\n If the record is not yet available, the store will ask the adapter's `find`\n method to find the necessary data. If the record is already present in the\n 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 fetching the post you can pass in the post to the `findRecord` call:\n ```javascript\n store.findRecord('comment', 2, { preload: { post: 1 } });\n ```\n If you have access to the post model you can also pass the model itself:\n ```javascript\n store.findRecord('post', 1).then(function (myPostModel) {\n store.findRecord('comment', 2, { post: myPostModel });\n });\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](../classes/Store/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 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 = this._super(...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 @param {String} modelName\n @param {(String|Integer)} id\n @param {Object} [options]\n @param {Object} preload - optional set of attributes and relationships passed in either as IDs or as actual models\n @return {Promise} promise\n */\n ;\n\n _proto.findRecord = function findRecord(modelName, id, options) {\n {\n assertDestroyingStore(this, 'findRecord');\n }\n\n ( !(Ember.isPresent(modelName)) && Ember.assert(\"You need to pass a model name to the store's findRecord method\", Ember.isPresent(modelName)));\n ( !(typeof modelName === 'string') && Ember.assert(\"Passing classes to store methods has been removed. Please pass a dasherized string instead of \" + modelName, typeof modelName === 'string'));\n var type = normalizeModelName(modelName);\n var normalizedId = ensureStringId(id);\n var resource = constructResource(type, normalizedId);\n var internalModel = internalModelFactoryFor(this).lookup(resource);\n options = options || {};\n\n if (!this.hasRecordForId(type, normalizedId)) {\n return this._findByInternalModel(internalModel, options);\n }\n\n var fetchedInternalModel = this._findRecord(internalModel, options);\n\n return promiseRecord(fetchedInternalModel, \"DS: Store#findRecord \" + type + \" with id: \" + id);\n };\n\n _proto._findRecord = function _findRecord(internalModel, options) {\n // Refetch if the reload option is passed\n if (options.reload) {\n return this._scheduleFetch(internalModel, options);\n }\n\n var snapshot = internalModel.createSnapshot(options);\n var adapter = this.adapterFor(internalModel.modelName); // Refetch the record if the adapter thinks the record is stale\n\n if (typeof options.reload === 'undefined' && adapter.shouldReloadRecord && adapter.shouldReloadRecord(this, snapshot)) {\n return this._scheduleFetch(internalModel, options);\n }\n\n if (options.backgroundReload === false) {\n return Ember.RSVP.Promise.resolve(internalModel);\n } // Trigger the background refetch if backgroundReload option is passed\n\n\n if (options.backgroundReload || !adapter.shouldBackgroundReloadRecord || adapter.shouldBackgroundReloadRecord(this, snapshot)) {\n this._scheduleFetch(internalModel, options);\n } // Return the cached record\n\n\n return Ember.RSVP.Promise.resolve(internalModel);\n };\n\n _proto._findByInternalModel = function _findByInternalModel(internalModel, options) {\n if (options === void 0) {\n options = {};\n }\n\n if (options.preload) {\n internalModel.preloadData(options.preload);\n }\n\n var fetchedInternalModel = this._findEmptyInternalModel(internalModel, options);\n\n return promiseRecord(fetchedInternalModel, \"DS: Store#findRecord \" + internalModel.modelName + \" with id: \" + internalModel.id);\n };\n\n _proto._findEmptyInternalModel = function _findEmptyInternalModel(internalModel, options) {\n if (internalModel.isEmpty()) {\n return this._scheduleFetch(internalModel, options);\n } //TODO double check about reloading\n\n\n {\n if (internalModel.isLoading()) {\n return internalModel._promiseProxy;\n }\n }\n\n return Ember.RSVP.Promise.resolve(internalModel);\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 ;\n\n _proto.findByIds = function findByIds(modelName, ids) {\n {\n assertDestroyingStore(this, 'findByIds');\n }\n\n ( !(Ember.isPresent(modelName)) && Ember.assert(\"You need to pass a model name to the store's findByIds method\", Ember.isPresent(modelName)));\n ( !(typeof modelName === 'string') && Ember.assert(\"Passing classes to store methods has been removed. Please pass a dasherized string instead of \" + modelName, typeof modelName === 'string'));\n var promises = new Array(ids.length);\n var normalizedModelName = normalizeModelName(modelName);\n\n for (var i = 0; i < ids.length; i++) {\n promises[i] = this.findRecord(normalizedModelName, ids[i]);\n }\n\n return promiseArray(Ember.RSVP.all(promises).then(Ember.A, null, \"DS: Store#findByIds of \" + normalizedModelName + \" complete\"));\n }\n /**\n This method is called by `findRecord` if it discovers that a particular\n type/id pair hasn't been loaded yet to kick off a request to the\n adapter.\n @method _fetchRecord\n @private\n @param {InternalModel} internalModel model\n @return {Promise} promise\n */\n ;\n\n _proto._fetchRecord = function _fetchRecord(internalModel, options) {\n var modelName = internalModel.modelName;\n var adapter = this.adapterFor(modelName);\n ( !(adapter) && Ember.assert(\"You tried to find a record but you have no adapter (for \" + modelName + \")\", adapter));\n ( !(typeof adapter.findRecord === 'function') && Ember.assert(\"You tried to find a record but your adapter (for \" + modelName + \") does not implement 'findRecord'\", typeof adapter.findRecord === 'function'));\n return _find(adapter, this, internalModel.type, internalModel.id, internalModel, options);\n };\n\n _proto._scheduleFetchMany = function _scheduleFetchMany(internalModels, options) {\n var fetches = new Array(internalModels.length);\n\n for (var i = 0; i < internalModels.length; i++) {\n fetches[i] = this._scheduleFetch(internalModels[i], options);\n }\n\n return Ember.RSVP.Promise.all(fetches);\n };\n\n _proto._scheduleFetchThroughFetchManager = function _scheduleFetchThroughFetchManager(internalModel, options) {\n var _this3 = this;\n\n if (options === void 0) {\n options = {};\n }\n\n var generateStackTrace = this.generateStackTracesForTrackedRequests; // TODO remove this once we don't rely on state machine\n\n internalModel.loadingData();\n var identifier = internalModel.identifier;\n assertIdentifierHasId(identifier);\n\n var promise = this._fetchManager.scheduleFetch(identifier, options, generateStackTrace);\n\n return promise.then(function (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 } // Returning this._push here, breaks typing but not any tests, investigate potential missing tests\n\n\n var potentiallyNewIm = _this3._push(payload);\n\n if (potentiallyNewIm && !Array.isArray(potentiallyNewIm)) {\n return potentiallyNewIm;\n } else {\n return internalModel;\n }\n }, function (error) {\n // TODO remove this once we don't rely on state machine\n internalModel.notFound();\n\n if (internalModel.isEmpty()) {\n internalModel.unloadRecord();\n }\n\n throw error;\n });\n };\n\n _proto._scheduleFetch = function _scheduleFetch(internalModel, options) {\n {\n if (internalModel._promiseProxy) {\n return internalModel._promiseProxy;\n }\n\n var id = internalModel.id,\n modelName = internalModel.modelName;\n var resolver = Ember.RSVP.defer(\"Fetching \" + modelName + \"' with id: \" + id);\n var pendingFetchItem = {\n internalModel: internalModel,\n resolver: resolver,\n options: options\n };\n\n {\n if (this.generateStackTracesForTrackedRequests === true) {\n var trace;\n\n try {\n throw new Error(\"Trace Origin for scheduled fetch for \" + modelName + \":\" + id + \".\");\n } catch (e) {\n trace = e;\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\n\n pendingFetchItem.trace = trace;\n }\n }\n\n var promise = resolver.promise;\n internalModel.loadingData(promise);\n\n if (this._pendingFetch.size === 0) {\n emberRun$2.schedule('actions', this, this.flushAllPendingFetches);\n }\n\n var fetches = this._pendingFetch;\n var pending = fetches.get(modelName);\n\n if (pending === undefined) {\n pending = [];\n fetches.set(modelName, pending);\n }\n\n pending.push(pendingFetchItem);\n return promise;\n }\n };\n\n _proto.flushAllPendingFetches = function flushAllPendingFetches() {\n {\n if (this.isDestroyed || this.isDestroying) {\n return;\n }\n\n this._pendingFetch.forEach(this._flushPendingFetchForType, this);\n\n this._pendingFetch.clear();\n }\n };\n\n _proto._flushPendingFetchForType = function _flushPendingFetchForType(pendingFetchItems, modelName) {\n var store = this;\n var adapter = store.adapterFor(modelName);\n var shouldCoalesce = !!adapter.findMany && adapter.coalesceFindRequests;\n var totalItems = pendingFetchItems.length;\n var internalModels = new Array(totalItems);\n var seeking = Object.create(null);\n var optionsMap = new WeakMap();\n\n for (var _i = 0; _i < totalItems; _i++) {\n var pendingItem = pendingFetchItems[_i];\n var _internalModel = pendingItem.internalModel;\n internalModels[_i] = _internalModel;\n optionsMap.set(_internalModel, pendingItem.options); // We can remove this \"not null\" cast once we have enough typing\n // to know we are only dealing with ExistingResourceIdentifierObjects\n\n seeking[_internalModel.id] = pendingItem;\n }\n\n function _fetchRecord(recordResolverPair) {\n var recordFetch = store._fetchRecord(recordResolverPair.internalModel, recordResolverPair.options);\n\n recordResolverPair.resolver.resolve(recordFetch);\n }\n\n function handleFoundRecords(foundInternalModels, expectedInternalModels) {\n // resolve found records\n var found = Object.create(null);\n\n for (var _i2 = 0, _l = foundInternalModels.length; _i2 < _l; _i2++) {\n var _internalModel2 = foundInternalModels[_i2]; // We can remove this \"not null\" cast once we have enough typing\n // to know we are only dealing with ExistingResourceIdentifierObjects\n\n var _pair = seeking[_internalModel2.id];\n found[_internalModel2.id] = _internalModel2;\n\n if (_pair) {\n var resolver = _pair.resolver;\n resolver.resolve(_internalModel2);\n }\n } // reject missing records\n\n\n var missingInternalModels = [];\n\n for (var _i3 = 0, _l2 = expectedInternalModels.length; _i3 < _l2; _i3++) {\n var _internalModel3 = expectedInternalModels[_i3]; // We can remove this \"not null\" cast once we have enough typing\n // to know we are only dealing with ExistingResourceIdentifierObjects\n\n if (!found[_internalModel3.id]) {\n missingInternalModels.push(_internalModel3);\n }\n }\n\n if (missingInternalModels.length) {\n ( Ember.warn('Ember Data expected to find records with the following ids in the adapter response but they were missing: [ \"' + missingInternalModels.map(function (r) {\n return r.id;\n }).join('\", \"') + '\" ]', false, {\n id: 'ds.store.missing-records-from-adapter'\n }));\n rejectInternalModels(missingInternalModels);\n }\n }\n\n function rejectInternalModels(internalModels, error) {\n for (var _i4 = 0, _l3 = internalModels.length; _i4 < _l3; _i4++) {\n var _internalModel4 = internalModels[_i4]; // We can remove this \"not null\" cast once we have enough typing\n // to know we are only dealing with ExistingResourceIdentifierObjects\n\n var _pair2 = seeking[_internalModel4.id];\n\n if (_pair2) {\n _pair2.resolver.reject(error || new Error(\"Expected: '\" + _internalModel4 + \"' to be present in the adapter provided payload, but it was not found.\"));\n }\n }\n }\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 var snapshots = new Array(totalItems);\n\n for (var _i5 = 0; _i5 < totalItems; _i5++) {\n snapshots[_i5] = internalModels[_i5].createSnapshot(optionsMap.get(internalModel));\n }\n\n var groups;\n\n if (adapter.groupRecordsForFindMany) {\n groups = adapter.groupRecordsForFindMany(this, snapshots);\n } else {\n groups = [snapshots];\n }\n\n for (var i = 0, l = groups.length; i < l; i++) {\n var group = groups[i];\n var totalInGroup = groups[i].length;\n var ids = new Array(totalInGroup);\n var groupedInternalModels = new Array(totalInGroup);\n\n for (var j = 0; j < totalInGroup; j++) {\n var internalModel = group[j]._internalModel;\n groupedInternalModels[j] = internalModel;\n ids[j] = internalModel.id;\n }\n\n if (totalInGroup > 1) {\n (function (groupedInternalModels) {\n _findMany(adapter, store, modelName, ids, groupedInternalModels, optionsMap).then(function (foundInternalModels) {\n handleFoundRecords(foundInternalModels, groupedInternalModels);\n }).catch(function (error) {\n rejectInternalModels(groupedInternalModels, error);\n });\n })(groupedInternalModels);\n } else if (ids.length === 1) {\n var pair = seeking[groupedInternalModels[0].id];\n\n _fetchRecord(pair);\n } else {\n ( Ember.assert(\"You cannot return an empty array from adapter's method groupRecordsForFindMany\", false));\n }\n }\n } else {\n for (var _i6 = 0; _i6 < totalItems; _i6++) {\n _fetchRecord(pendingFetchItems[_i6]);\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 @param {String} modelName\n @param {String|Integer} id\n @since 2.5.0\n @return {RecordReference}\n */\n ;\n\n _proto.getReference = function getReference(modelName, id) {\n {\n assertDestroyingStore(this, 'getReference');\n }\n\n var type = normalizeModelName(modelName);\n var normalizedId = ensureStringId(id);\n var resource = constructResource(type, normalizedId);\n var identifier = identifierCacheFor(this).getOrCreateRecordIdentifier(resource);\n\n if (identifier) {\n if (RECORD_REFERENCES.has(identifier)) {\n return RECORD_REFERENCES.get(identifier);\n }\n\n var reference = new RecordReference(this, identifier);\n RECORD_REFERENCES.set(identifier, reference);\n return reference;\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](../classes/Store/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 ```js\n let post = store.peekRecord('post', 1);\n post.get('id'); // 1\n ```\n @since 1.13.0\n @method peekRecord\n @param {String} modelName\n @param {String|Integer} id\n @return {Model|null} record\n */\n ;\n\n _proto.peekRecord = function peekRecord(modelName, id) {\n {\n assertDestroyingStore(this, 'peekRecord');\n }\n\n ( !(Ember.isPresent(modelName)) && Ember.assert(\"You need to pass a model name to the store's peekRecord method\", Ember.isPresent(modelName)));\n ( !(typeof modelName === 'string') && Ember.assert(\"Passing classes to store methods has been removed. Please pass a dasherized string instead of \" + modelName, typeof modelName === 'string'));\n var type = normalizeModelName(modelName);\n var normalizedId = ensureStringId(id);\n\n if (this.hasRecordForId(type, normalizedId)) {\n var resource = constructResource(type, normalizedId);\n return internalModelFactoryFor(this).lookup(resource).getRecord();\n } else {\n return null;\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 ;\n\n _proto._reloadRecord = function _reloadRecord(internalModel, options) {\n\n var id = internalModel.id,\n modelName = internalModel.modelName;\n var adapter = this.adapterFor(modelName);\n ( !(id) && Ember.assert(\"You cannot reload a record without an ID\", id));\n ( !(adapter) && Ember.assert(\"You tried to reload a record but you have no adapter (for \" + modelName + \")\", adapter));\n ( !(typeof adapter.findRecord === 'function' || typeof adapter.find === 'function') && Ember.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 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 @param {String} modelName\n @param {(String|Integer)} id\n @return {Boolean}\n */\n ;\n\n _proto.hasRecordForId = function hasRecordForId(modelName, id) {\n {\n assertDestroyingStore(this, 'hasRecordForId');\n }\n\n ( !(Ember.isPresent(modelName)) && Ember.assert(\"You need to pass a model name to the store's hasRecordForId method\", Ember.isPresent(modelName)));\n ( !(typeof modelName === 'string') && Ember.assert(\"Passing classes to store methods has been removed. Please pass a dasherized string instead of \" + modelName, typeof modelName === 'string'));\n var type = normalizeModelName(modelName);\n var trueId = ensureStringId(id);\n var resource = {\n type: type,\n id: trueId\n };\n var identifier = identifierCacheFor(this).peekRecordIdentifier(resource);\n var internalModel = identifier && internalModelFactoryFor(this).peek(identifier);\n return !!internalModel && internalModel.isLoaded();\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 ;\n\n _proto.recordForId = function recordForId(modelName, id) {\n {\n assertDestroyingStore(this, 'recordForId');\n }\n\n ( !(Ember.isPresent(modelName)) && Ember.assert(\"You need to pass a model name to the store's recordForId method\", Ember.isPresent(modelName)));\n ( !(typeof modelName === 'string') && Ember.assert(\"Passing classes to store methods has been removed. Please pass a dasherized string instead of \" + modelName, typeof modelName === 'string'));\n var resource = constructResource(modelName, ensureStringId(id));\n return internalModelFactoryFor(this).lookup(resource).getRecord();\n }\n /**\n @method findMany\n @private\n @param {Array} internalModels\n @return {Promise} promise\n */\n ;\n\n _proto.findMany = function findMany(internalModels, options) {\n {\n assertDestroyingStore(this, 'findMany');\n }\n\n var finds = new Array(internalModels.length);\n\n for (var i = 0; i < internalModels.length; i++) {\n finds[i] = this._findEmptyInternalModel(internalModels[i], options);\n }\n\n return Ember.RSVP.Promise.all(finds);\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 ;\n\n _proto.findHasMany = function findHasMany(internalModel, link, relationship, options) {\n {\n assertDestroyingStore(this, 'findHasMany');\n }\n\n var adapter = this.adapterFor(internalModel.modelName);\n ( !(adapter) && Ember.assert(\"You tried to load a hasMany relationship but you have no adapter (for \" + internalModel.modelName + \")\", adapter));\n ( !(typeof adapter.findHasMany === 'function') && Ember.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\n _proto._findHasManyByJsonApiResource = function _findHasManyByJsonApiResource(resource, parentInternalModel, relationshipMeta, options) {\n var _this4 = this;\n\n if (!resource) {\n return Ember.RSVP.resolve([]);\n }\n\n var adapter = this.adapterFor(relationshipMeta.type);\n var _resource$_relationsh = resource._relationship,\n relationshipIsStale = _resource$_relationsh.relationshipIsStale,\n hasDematerializedInverse = _resource$_relationsh.hasDematerializedInverse,\n hasAnyRelationshipData = _resource$_relationsh.hasAnyRelationshipData,\n relationshipIsEmpty = _resource$_relationsh.relationshipIsEmpty,\n shouldForceReload = _resource$_relationsh.shouldForceReload;\n var allInverseRecordsAreLoaded = areAllInverseRecordsLoaded(this, resource);\n var shouldFindViaLink = resource.links && resource.links.related && (typeof adapter.findHasMany === 'function' || typeof resource.data === 'undefined') && (shouldForceReload || hasDematerializedInverse || relationshipIsStale || !allInverseRecordsAreLoaded && !relationshipIsEmpty); // fetch via link\n\n if (shouldFindViaLink) {\n return this.findHasMany(parentInternalModel, resource.links.related, relationshipMeta, options);\n }\n\n var preferLocalCache = hasAnyRelationshipData && !relationshipIsEmpty;\n var hasLocalPartialData = hasDematerializedInverse || relationshipIsEmpty && Array.isArray(resource.data) && resource.data.length > 0; // fetch using data, pulling from local cache if possible\n\n if (!shouldForceReload && !relationshipIsStale && (preferLocalCache || hasLocalPartialData)) {\n var internalModels = resource.data.map(function (json) {\n return _this4._internalModelForResource(json);\n });\n return this.findMany(internalModels, options);\n }\n\n var hasData = hasAnyRelationshipData && !relationshipIsEmpty; // fetch by data\n\n if (hasData || hasLocalPartialData) {\n var _internalModels = resource.data.map(function (json) {\n return _this4._internalModelForResource(json);\n });\n\n return this._scheduleFetchMany(_internalModels, options);\n } // we were explicitly told we have no data and no links.\n // TODO if the relationshipIsStale, should we hit the adapter anyway?\n\n\n return Ember.RSVP.resolve([]);\n };\n\n _proto._getHasManyByJsonApiResource = function _getHasManyByJsonApiResource(resource) {\n var _this5 = this;\n\n var internalModels = [];\n\n if (resource && resource.data) {\n internalModels = resource.data.map(function (reference) {\n return _this5._internalModelForResource(reference);\n });\n }\n\n return internalModels;\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 ;\n\n _proto.findBelongsTo = function findBelongsTo(internalModel, link, relationship, options) {\n {\n assertDestroyingStore(this, 'findBelongsTo');\n }\n\n var adapter = this.adapterFor(internalModel.modelName);\n ( !(adapter) && Ember.assert(\"You tried to load a belongsTo relationship but you have no adapter (for \" + internalModel.modelName + \")\", adapter));\n ( !(typeof adapter.findBelongsTo === 'function') && Ember.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\n _proto._fetchBelongsToLinkFromResource = function _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 Ember.RSVP.resolve(null);\n }\n\n return this.findBelongsTo(parentInternalModel, resource.links.related, relationshipMeta, options).then(function (internalModel) {\n return internalModel ? internalModel.getRecord() : null;\n });\n };\n\n _proto._findBelongsToByJsonApiResource = function _findBelongsToByJsonApiResource(resource, parentInternalModel, relationshipMeta, options) {\n if (!resource) {\n return Ember.RSVP.resolve(null);\n }\n\n var internalModel = resource.data ? this._internalModelForResource(resource.data) : null;\n var _resource$_relationsh2 = resource._relationship,\n relationshipIsStale = _resource$_relationsh2.relationshipIsStale,\n hasDematerializedInverse = _resource$_relationsh2.hasDematerializedInverse,\n hasAnyRelationshipData = _resource$_relationsh2.hasAnyRelationshipData,\n relationshipIsEmpty = _resource$_relationsh2.relationshipIsEmpty,\n shouldForceReload = _resource$_relationsh2.shouldForceReload;\n var allInverseRecordsAreLoaded = areAllInverseRecordsLoaded(this, resource);\n var shouldFindViaLink = resource.links && resource.links.related && (shouldForceReload || hasDematerializedInverse || relationshipIsStale || !allInverseRecordsAreLoaded && !relationshipIsEmpty);\n\n if (internalModel) {\n // short circuit if we are already loading\n {\n if (internalModel.isLoading()) {\n return internalModel._promiseProxy.then(function () {\n return internalModel.getRecord();\n });\n }\n }\n } // fetch via link\n\n\n if (shouldFindViaLink) {\n return this._fetchBelongsToLinkFromResource(resource, parentInternalModel, relationshipMeta, options);\n }\n\n var preferLocalCache = hasAnyRelationshipData && allInverseRecordsAreLoaded && !relationshipIsEmpty;\n var hasLocalPartialData = hasDematerializedInverse || relationshipIsEmpty && resource.data; // null is explicit empty, undefined is \"we don't know anything\"\n\n var localDataIsEmpty = resource.data === undefined || resource.data === null; // fetch using data, pulling from local cache if possible\n\n if (!shouldForceReload && !relationshipIsStale && (preferLocalCache || hasLocalPartialData)) {\n /*\n We have canonical data, but our local state is empty\n */\n if (localDataIsEmpty) {\n return Ember.RSVP.resolve(null);\n }\n\n return this._findByInternalModel(internalModel, options);\n }\n\n var resourceIsLocal = !localDataIsEmpty && resource.data.id === null;\n\n if (internalModel && resourceIsLocal) {\n return Ember.RSVP.resolve(internalModel.getRecord());\n } // fetch by data\n\n\n if (internalModel && !localDataIsEmpty) {\n return this._scheduleFetch(internalModel, options).then(function () {\n return internalModel.getRecord();\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\n\n return Ember.RSVP.resolve(null);\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 @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 ;\n\n _proto.query = function query(modelName, _query2, options) {\n {\n assertDestroyingStore(this, 'query');\n }\n\n ( !(Ember.isPresent(modelName)) && Ember.assert(\"You need to pass a model name to the store's query method\", Ember.isPresent(modelName)));\n ( !(_query2) && Ember.assert(\"You need to pass a query hash to the store's query method\", _query2));\n ( !(typeof modelName === 'string') && Ember.assert(\"Passing classes to store methods has been removed. Please pass a dasherized string instead of \" + modelName, typeof modelName === 'string'));\n var adapterOptionsWrapper = {};\n\n if (options && options.adapterOptions) {\n adapterOptionsWrapper.adapterOptions = options.adapterOptions;\n }\n\n var normalizedModelName = normalizeModelName(modelName);\n return this._query(normalizedModelName, _query2, null, adapterOptionsWrapper);\n };\n\n _proto._query = function _query$1(modelName, query, array, options) {\n ( !(Ember.isPresent(modelName)) && Ember.assert(\"You need to pass a model name to the store's query method\", Ember.isPresent(modelName)));\n ( !(query) && Ember.assert(\"You need to pass a query hash to the store's query method\", query));\n ( !(typeof modelName === 'string') && Ember.assert(\"Passing classes to store methods has been removed. Please pass a dasherized string instead of \" + modelName, typeof modelName === 'string'));\n var adapter = this.adapterFor(modelName);\n ( !(adapter) && Ember.assert(\"You tried to load a query but you have no adapter (for \" + modelName + \")\", adapter));\n ( !(typeof adapter.query === 'function') && Ember.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 This method makes a request for one record, where the `id` is not known\n beforehand (if the `id` is known, use [`findRecord`](../classes/Store/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 @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 ;\n\n _proto.queryRecord = function queryRecord(modelName, query, options) {\n {\n assertDestroyingStore(this, 'queryRecord');\n }\n\n ( !(Ember.isPresent(modelName)) && Ember.assert(\"You need to pass a model name to the store's queryRecord method\", Ember.isPresent(modelName)));\n ( !(query) && Ember.assert(\"You need to pass a query hash to the store's queryRecord method\", query));\n ( !(typeof modelName === 'string') && Ember.assert(\"Passing classes to store methods has been removed. Please pass a dasherized string instead of \" + modelName, typeof modelName === 'string'));\n var normalizedModelName = normalizeModelName(modelName);\n var adapter = this.adapterFor(normalizedModelName);\n var adapterOptionsWrapper = {};\n\n if (options && options.adapterOptions) {\n adapterOptionsWrapper.adapterOptions = options.adapterOptions;\n }\n\n ( !(adapter) && Ember.assert(\"You tried to make a query but you have no adapter (for \" + normalizedModelName + \")\", adapter));\n ( !(typeof adapter.queryRecord === 'function') && Ember.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(function (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\n return null;\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](../classes/Store/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](../classes/Store/methods/query?anchor=query) to only get a subset of records from the server.\n @since 1.13.0\n @method findAll\n @param {String} modelName\n @param {Object} options\n @return {Promise} promise\n */\n ;\n\n _proto.findAll = function findAll(modelName, options) {\n {\n assertDestroyingStore(this, 'findAll');\n }\n\n ( !(Ember.isPresent(modelName)) && Ember.assert(\"You need to pass a model name to the store's findAll method\", Ember.isPresent(modelName)));\n ( !(typeof modelName === 'string') && Ember.assert(\"Passing classes to store methods has been removed. Please pass a dasherized string instead of \" + modelName, typeof modelName === 'string'));\n var normalizedModelName = normalizeModelName(modelName);\n\n var fetch = this._fetchAll(normalizedModelName, this.peekAll(normalizedModelName), options);\n\n return fetch;\n }\n /**\n @method _fetchAll\n @private\n @param {Model} modelName\n @param {RecordArray} array\n @return {Promise} promise\n */\n ;\n\n _proto._fetchAll = function _fetchAll(modelName, array, options) {\n if (options === void 0) {\n options = {};\n }\n\n var adapter = this.adapterFor(modelName);\n ( !(adapter) && Ember.assert(\"You tried to load all records but you have no adapter (for \" + modelName + \")\", adapter));\n ( !(typeof adapter.findAll === 'function') && Ember.assert(\"You tried to load all records but your adapter does not implement 'findAll'\", typeof adapter.findAll === 'function'));\n\n if (options.reload) {\n Ember.set(array, 'isUpdating', true);\n return promiseArray(_findAll(adapter, this, modelName, options));\n }\n\n var snapshotArray = array._createSnapshot(options);\n\n if (options.reload !== false) {\n if (adapter.shouldReloadAll && adapter.shouldReloadAll(this, snapshotArray) || !adapter.shouldReloadAll && snapshotArray.length === 0) {\n Ember.set(array, 'isUpdating', true);\n return promiseArray(_findAll(adapter, this, modelName, options));\n }\n }\n\n if (options.backgroundReload === false) {\n return promiseArray(Ember.RSVP.Promise.resolve(array));\n }\n\n if (options.backgroundReload || !adapter.shouldBackgroundReloadAll || adapter.shouldBackgroundReloadAll(this, snapshotArray)) {\n Ember.set(array, 'isUpdating', true);\n\n _findAll(adapter, this, modelName, options);\n }\n\n return promiseArray(Ember.RSVP.Promise.resolve(array));\n }\n /**\n @method _didUpdateAll\n @param {String} modelName\n @private\n */\n ;\n\n _proto._didUpdateAll = function _didUpdateAll(modelName) {\n this.recordArrayManager._didUpdateAll(modelName);\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](../classes/Store/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 @param {String} modelName\n @return {RecordArray}\n */\n ;\n\n _proto.peekAll = function peekAll(modelName) {\n {\n assertDestroyingStore(this, 'peekAll');\n }\n\n ( !(Ember.isPresent(modelName)) && Ember.assert(\"You need to pass a model name to the store's peekAll method\", Ember.isPresent(modelName)));\n ( !(typeof modelName === 'string') && Ember.assert(\"Passing classes to store methods has been removed. Please pass a dasherized string instead of \" + modelName, typeof modelName === 'string'));\n var normalizedModelName = normalizeModelName(modelName);\n return this.recordArrayManager.liveRecordArrayFor(normalizedModelName);\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 @param {String} modelName\n */\n ;\n\n _proto.unloadAll = function unloadAll(modelName) {\n {\n assertDestroyedStoreOnly(this, 'unloadAll');\n }\n\n ( !(!modelName || typeof modelName === 'string') && Ember.assert(\"Passing classes to store methods has been removed. Please pass a dasherized string instead of \" + modelName, !modelName || typeof modelName === 'string'));\n var factory = internalModelFactoryFor(this);\n\n if (modelName === undefined) {\n factory.clear();\n } else {\n var normalizedModelName = normalizeModelName(modelName);\n factory.clear(normalizedModelName);\n }\n };\n\n _proto.filter = function filter() {\n ( Ember.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 // . 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 ;\n\n _proto.scheduleSave = function scheduleSave(internalModel, resolver, options) {\n\n var snapshot = internalModel.createSnapshot(options);\n\n if (internalModel._isRecordFullyDeleted()) {\n resolver.resolve();\n return resolver.promise;\n }\n\n internalModel.adapterWillCommit();\n\n this._pendingSave.push({\n snapshot: snapshot,\n resolver: resolver\n });\n\n emberRun$2.scheduleOnce('actions', this, this.flushPendingSave);\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 ;\n\n _proto.flushPendingSave = function flushPendingSave() {\n\n var pending = this._pendingSave.slice();\n\n this._pendingSave = [];\n\n for (var i = 0, j = pending.length; i < j; i++) {\n var pendingItem = pending[i];\n var snapshot = pendingItem.snapshot;\n var resolver = pendingItem.resolver; // 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\n var internalModel = snapshot._internalModel;\n var adapter = this.adapterFor(internalModel.modelName);\n var operation = void 0;\n\n {\n if (internalModel.currentState.stateName === 'root.deleted.saved') {\n resolver.resolve();\n continue;\n } else if (internalModel.isNew()) {\n operation = 'createRecord';\n } else if (internalModel.isDeleted()) {\n operation = 'deleteRecord';\n } else {\n operation = 'updateRecord';\n }\n }\n\n resolver.resolve(_commit(adapter, this, operation, snapshot));\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 ;\n\n _proto.didSaveRecord = function didSaveRecord(internalModel, dataArg, op) {\n {\n assertDestroyingStore(this, 'didSaveRecord');\n }\n\n var data;\n\n if (dataArg) {\n data = dataArg.data;\n }\n\n if (!data) {\n ( !(internalModel.id) && Ember.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\n var cache = identifierCacheFor(this);\n var identifier = internalModel.identifier;\n\n if (op !== 'deleteRecord' && data) {\n cache.updateRecordIdentifier(identifier, data);\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\n\n internalModel.adapterDidCommit(data);\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 ;\n\n _proto.recordWasInvalid = function recordWasInvalid(internalModel, parsedErrors, error) {\n {\n assertDestroyingStore(this, 'recordWasInvalid');\n }\n\n {\n internalModel.adapterDidInvalidate(parsedErrors);\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 ;\n\n _proto.recordWasError = function recordWasError(internalModel, error) {\n {\n assertDestroyingStore(this, 'recordWasError');\n }\n\n internalModel.adapterDidError(error);\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 ;\n\n _proto.setRecordId = function setRecordId(modelName, newId, clientId) {\n {\n assertDestroyingStore(this, 'setRecordId');\n }\n\n internalModelFactoryFor(this).setRecordId(modelName, newId, clientId);\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 ;\n\n _proto._load = function _load(data) {\n var resource = constructResource(normalizeModelName(data.type), ensureStringId(data.id), coerceId(data.lid));\n var internalModel = internalModelFactoryFor(this).lookup(resource, data); // store.push will be from empty\n // findRecord will be from root.loading\n // all else will be updates\n\n var isLoading = internalModel.currentState.stateName === 'root.loading';\n var isUpdate = internalModel.currentState.isEmpty === false && !isLoading; // exclude store.push (root.empty) case\n\n var identifier = internalModel.identifier;\n\n if (isUpdate || isLoading) {\n var updatedIdentifier = identifierCacheFor(this).updateRecordIdentifier(identifier, data);\n\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\n internalModel.setupData(data);\n\n if (!isUpdate) {\n this.recordArrayManager.recordDidChange(identifier);\n }\n\n return internalModel;\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](../classes/Store/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 @param {Object} data\n @return the record(s) that was created or\n updated.\n */\n ;\n\n _proto.push = function push(data) {\n {\n assertDestroyingStore(this, 'push');\n }\n\n var pushed = this._push(data);\n\n if (Array.isArray(pushed)) {\n var records = pushed.map(function (internalModel) {\n return internalModel.getRecord();\n });\n return records;\n }\n\n if (pushed === null) {\n return null;\n }\n\n var record = pushed.getRecord();\n return record;\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 ;\n\n _proto._push = function _push(jsonApiDoc) {\n var _this7 = this;\n\n {\n assertDestroyingStore(this, '_push');\n }\n\n var internalModelOrModels = this._backburner.join(function () {\n var included = jsonApiDoc.included;\n var i, length;\n\n if (included) {\n for (i = 0, length = included.length; i < length; i++) {\n _this7._pushInternalModel(included[i]);\n }\n }\n\n if (Array.isArray(jsonApiDoc.data)) {\n length = jsonApiDoc.data.length;\n var internalModels = new Array(length);\n\n for (i = 0; i < length; i++) {\n internalModels[i] = _this7._pushInternalModel(jsonApiDoc.data[i]);\n }\n\n return internalModels;\n }\n\n if (jsonApiDoc.data === null) {\n return null;\n }\n\n ( !(Ember.typeOf(jsonApiDoc.data) === 'object') && Ember.assert(\"Expected an object in the 'data' property in a call to 'push' for \" + jsonApiDoc.type + \", but was \" + Ember.typeOf(jsonApiDoc.data), Ember.typeOf(jsonApiDoc.data) === 'object'));\n return _this7._pushInternalModel(jsonApiDoc.data);\n }); // this typecast is necessary because `backburner.join` is mistyped to return void\n\n\n return internalModelOrModels;\n };\n\n _proto._pushInternalModel = function _pushInternalModel(data) {\n var modelName = data.type;\n ( !(data.id !== null && data.id !== undefined && data.id !== '') && Ember.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)) && Ember.assert(\"You tried to push data with a type '\" + modelName + \"' but no model could be found with that name.\", this._hasModelFor(modelName)));\n\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 if (ENV.DS_WARN_ON_UNKNOWN_KEYS) {\n var unknownAttributes, unknownRelationships;\n\n {\n var modelClass = this.modelFor(modelName); // Check unknown attributes\n\n unknownAttributes = Object.keys(data.attributes || {}).filter(function (key) {\n return !Ember.get(modelClass, 'fields').has(key);\n }); // Check unknown relationships\n\n unknownRelationships = Object.keys(data.relationships || {}).filter(function (key) {\n return !Ember.get(modelClass, 'fields').has(key);\n });\n }\n\n var unknownAttributesMessage = \"The payload for '\" + modelName + \"' contains these unknown attributes: \" + unknownAttributes + \". Make sure they've been defined in your model.\";\n ( Ember.warn(unknownAttributesMessage, unknownAttributes.length === 0, {\n id: 'ds.store.unknown-keys-in-payload'\n }));\n var unknownRelationshipsMessage = \"The payload for '\" + modelName + \"' contains these unknown relationships: \" + unknownRelationships + \". Make sure they've been defined in your model.\";\n ( Ember.warn(unknownRelationshipsMessage, unknownRelationships.length === 0, {\n id: 'ds.store.unknown-keys-in-payload'\n }));\n }\n } // Actually load the record into the store.\n\n\n var internalModel = this._load(data); // this._setupRelationshipsForModel(internalModel, data);\n\n\n return internalModel;\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 @param {String} modelName Optionally, a model type used to determine which serializer will be used\n @param {Object} inputPayload\n */\n ;\n\n _proto.pushPayload = function pushPayload(modelName, inputPayload) {\n {\n assertDestroyingStore(this, 'pushPayload');\n }\n\n var serializer;\n var payload;\n\n if (!inputPayload) {\n payload = modelName;\n serializer = this.serializerFor('application');\n ( !(typeof serializer.pushPayload === 'function') && Ember.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') && Ember.assert(\"Passing classes to store methods has been removed. Please pass a dasherized string instead of \" + modelName, typeof modelName === 'string'));\n var normalizedModelName = normalizeModelName(modelName);\n serializer = this.serializerFor(normalizedModelName);\n }\n\n ( !(serializer.pushPayload) && Ember.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\n _proto.reloadManyArray = function reloadManyArray(manyArray, internalModel, key, options) {\n return internalModel.reloadHasMany(key, options);\n };\n\n _proto.reloadBelongsTo = function reloadBelongsTo(belongsToProxy, internalModel, key, options) {\n return internalModel.reloadBelongsTo(key, options);\n };\n\n _proto._internalModelForResource = function _internalModelForResource(resource) {\n return internalModelFactoryFor(this).getByResource(resource);\n }\n /**\n * TODO Only needed temporarily for test support\n *\n * @internal\n */\n ;\n\n _proto._internalModelForId = function _internalModelForId(type, id, lid) {\n var resource = constructResource(type, id, lid);\n return internalModelFactoryFor(this).lookup(resource);\n };\n\n _proto.serializeRecord = function serializeRecord(record, options) {\n\n assertInDebug('serializeRecord is only available when CUSTOM_MODEL_CLASS ff is on', false);\n };\n\n _proto.saveRecord = function saveRecord(record, options) {\n\n assertInDebug('saveRecord is only available when CUSTOM_MODEL_CLASS ff is on', false);\n };\n\n _proto.relationshipReferenceFor = function relationshipReferenceFor(identifier, key) {\n\n assertInDebug('relationshipReferenceFor is only available when CUSTOM_MODEL_CLASS ff is on', false);\n }\n /**\n * @internal\n */\n ;\n\n _proto._createRecordData = function _createRecordData(identifier) {\n return this.createRecordDataFor(identifier.type, identifier.id, identifier.lid, this._storeWrapper);\n }\n /**\n * Instantiation hook allowing applications or addons to configure the store\n * to utilize a custom RecordData implementation.\n *\n * @param modelName\n * @param id\n * @param clientId\n * @param storeWrapper\n */\n ;\n\n _proto.createRecordDataFor = function 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 ./bin/packages-for-commit.js && yarn test-external:ember-observer\n if (_RecordData === undefined) {\n _RecordData = require$1('@ember-data/record-data/-private').RecordData;\n }\n\n var _identifier5 = identifierCacheFor(this).getOrCreateRecordIdentifier({\n type: modelName,\n id: id,\n lid: clientId\n });\n\n return new _RecordData(_identifier5, storeWrapper);\n }\n }\n /**\n * @internal\n */\n ;\n\n _proto.__recordDataFor = function __recordDataFor(resource) {\n var identifier = identifierCacheFor(this).getOrCreateRecordIdentifier(resource);\n return this.recordDataFor(identifier, false);\n }\n /**\n * @internal\n */\n ;\n\n _proto.recordDataFor = function recordDataFor$1(identifier, isCreate) {\n var internalModel;\n\n if (isCreate === true) {\n internalModel = internalModelFactoryFor(this).build({\n type: identifier.type,\n id: null\n });\n internalModel.loadedData();\n internalModel.didCreateRecord();\n } else {\n internalModel = internalModelFactoryFor(this).lookup(identifier);\n }\n\n return recordDataFor(internalModel);\n }\n /**\n `normalize` converts a json payload into the normalized form that\n [push](../classes/Store/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 @param {String} modelName The name of the model type for this payload\n @param {Object} payload\n @return {Object} The normalized payload\n */\n ;\n\n _proto.normalize = function normalize(modelName, payload) {\n {\n assertDestroyingStore(this, 'normalize');\n }\n\n ( !(Ember.isPresent(modelName)) && Ember.assert(\"You need to pass a model name to the store's normalize method\", Ember.isPresent(modelName)));\n ( !(typeof modelName === 'string') && Ember.assert(\"Passing classes to store methods has been removed. Please pass a dasherized string instead of \" + Ember.inspect(modelName), typeof modelName === 'string'));\n var normalizedModelName = normalizeModelName(modelName);\n var serializer = this.serializerFor(normalizedModelName);\n var model = this.modelFor(normalizedModelName);\n ( !(serializer.normalize) && Ember.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\n _proto.newClientId = function newClientId() {\n assertInDebug(\"Private API Removed\", false);\n } // ...............\n // . DESTRUCTION .\n // ...............\n\n /**\n * TODO remove test usage\n *\n * @internal\n */\n ;\n\n _proto._internalModelsFor = function _internalModelsFor(modelName) {\n return internalModelFactoryFor(this).modelMapFor(modelName);\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 ;\n\n _proto.adapterFor = function adapterFor(modelName) {\n {\n assertDestroyingStore(this, 'adapterFor');\n }\n\n ( !(Ember.isPresent(modelName)) && Ember.assert(\"You need to pass a model name to the store's adapterFor method\", Ember.isPresent(modelName)));\n ( !(typeof modelName === 'string') && Ember.assert(\"Passing classes to store.adapterFor has been removed. Please pass a dasherized string instead of \" + modelName, typeof modelName === 'string'));\n var normalizedModelName = normalizeModelName(modelName);\n var _adapterCache = this._adapterCache;\n var adapter = _adapterCache[normalizedModelName];\n\n if (adapter) {\n return adapter;\n }\n\n var owner = Ember.getOwner(this);\n adapter = owner.lookup(\"adapter:\" + normalizedModelName); // in production this is handled by the re-export\n\n if ( adapter === undefined) {\n if (normalizedModelName === '-json-api') {\n var Adapter = require$1('@ember-data/adapter/json-api').default;\n\n owner.register(\"adapter:-json-api\", Adapter);\n adapter = owner.lookup(\"adapter:-json-api\");\n deprecateTestRegistration('adapter', '-json-api');\n }\n }\n\n if (adapter !== undefined) {\n Ember.set(adapter, 'store', this);\n _adapterCache[normalizedModelName] = adapter;\n return adapter;\n } // no adapter found for the specific model, fallback and check for application adapter\n\n\n adapter = _adapterCache.application || owner.lookup('adapter:application');\n\n if (adapter !== undefined) {\n Ember.set(adapter, 'store', this);\n _adapterCache[normalizedModelName] = adapter;\n _adapterCache.application = adapter;\n return adapter;\n } // no model specific adapter or application adapter, check for an `adapter`\n // property defined on the store\n\n\n var adapterName = this.adapter || '-json-api';\n adapter = adapterName ? _adapterCache[adapterName] || owner.lookup(\"adapter:\" + adapterName) : undefined; // in production this is handled by the re-export\n\n if ( adapter === undefined) {\n if (adapterName === '-json-api') {\n var _Adapter = require$1('@ember-data/adapter/json-api').default;\n\n owner.register(\"adapter:-json-api\", _Adapter);\n adapter = owner.lookup(\"adapter:-json-api\");\n deprecateTestRegistration('adapter', '-json-api');\n }\n }\n\n if (adapter !== undefined) {\n Ember.set(adapter, 'store', this);\n _adapterCache[normalizedModelName] = adapter;\n _adapterCache[adapterName] = adapter;\n return adapter;\n } // final fallback, no model specific adapter, no application adapter, no\n // `adapter` property on store: use json-api adapter\n\n\n adapter = _adapterCache['-json-api'] || owner.lookup('adapter:-json-api');\n ( !(adapter !== undefined) && Ember.assert(\"No adapter was found for '\" + modelName + \"' and no 'application' adapter was found as a fallback.\", adapter !== undefined));\n Ember.set(adapter, 'store', this);\n _adapterCache[normalizedModelName] = adapter;\n _adapterCache['-json-api'] = adapter;\n return adapter;\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 no `App.ApplicationSerializer` is found, it will attempt\n to get the `defaultSerializer` from the `PersonAdapter`\n (`adapterFor('person')`).\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 ;\n\n _proto.serializerFor = function serializerFor(modelName) {\n {\n assertDestroyingStore(this, 'serializerFor');\n }\n\n ( !(Ember.isPresent(modelName)) && Ember.assert(\"You need to pass a model name to the store's serializerFor method\", Ember.isPresent(modelName)));\n ( !(typeof modelName === 'string') && Ember.assert(\"Passing classes to store.serializerFor has been removed. Please pass a dasherized string instead of \" + modelName, typeof modelName === 'string'));\n var normalizedModelName = normalizeModelName(modelName);\n var _serializerCache = this._serializerCache;\n var serializer = _serializerCache[normalizedModelName];\n\n if (serializer) {\n return serializer;\n }\n\n var owner = Ember.getOwner(this);\n serializer = owner.lookup(\"serializer:\" + normalizedModelName);\n\n {\n // in production this is handled by the re-export\n if ( serializer === undefined) {\n if (normalizedModelName === '-json-api') {\n var Serializer = require$1('@ember-data/serializer/json-api').default;\n\n owner.register(\"serializer:-json-api\", Serializer);\n serializer = owner.lookup(\"serializer:-json-api\");\n deprecateTestRegistration('serializer', '-json-api');\n } else if (normalizedModelName === '-rest') {\n var _Serializer = require$1('@ember-data/serializer/rest').default;\n\n owner.register(\"serializer:-rest\", _Serializer);\n serializer = owner.lookup(\"serializer:-rest\");\n deprecateTestRegistration('serializer', '-rest');\n } else if (normalizedModelName === '-default') {\n var _Serializer2 = require$1('@ember-data/serializer/json').default;\n\n owner.register(\"serializer:-default\", _Serializer2);\n serializer = owner.lookup(\"serializer:-default\");\n serializer && deprecateTestRegistration('serializer', '-default');\n }\n }\n }\n\n if (serializer !== undefined) {\n Ember.set(serializer, 'store', this);\n _serializerCache[normalizedModelName] = serializer;\n return serializer;\n } // no serializer found for the specific model, fallback and check for application serializer\n\n\n serializer = _serializerCache.application || owner.lookup('serializer:application');\n\n if (serializer !== undefined) {\n Ember.set(serializer, 'store', this);\n _serializerCache[normalizedModelName] = serializer;\n _serializerCache.application = serializer;\n return serializer;\n }\n\n var serializerName;\n\n {\n // no model specific serializer or application serializer, check for the `defaultSerializer`\n // property defined on the adapter\n var adapter = this.adapterFor(modelName);\n serializerName = Ember.get(adapter, 'defaultSerializer');\n ( !(!serializerName) && Ember.deprecate(\"store.serializerFor(\\\"\" + modelName + \"\\\") resolved the \\\"\" + serializerName + \"\\\" serializer via the deprecated `adapter.defaultSerializer` property.\\n\\n\\tPreviously, if no application or type-specific serializer was specified, the store would attempt to lookup a serializer via the `defaultSerializer` property on the type's adapter. This behavior is deprecated in favor of explicitly defining a type-specific serializer or application serializer\", !serializerName, {\n id: 'ember-data:default-serializer',\n until: '4.0',\n url: 'https://deprecations.emberjs.com/ember-data/v3.x/#toc_ember-data-default-serializers'\n }));\n serializer = serializerName ? _serializerCache[serializerName] || owner.lookup(\"serializer:\" + serializerName) : undefined;\n }\n\n {\n // in production this is handled by the re-export\n if ( serializer === undefined) {\n if (serializerName === '-json-api') {\n var _Serializer3 = require$1('@ember-data/serializer/json-api').default;\n\n owner.register(\"serializer:-json-api\", _Serializer3);\n serializer = owner.lookup(\"serializer:-json-api\");\n deprecateTestRegistration('serializer', '-json-api');\n } else if (serializerName === '-rest') {\n var _Serializer4 = require$1('@ember-data/serializer/rest').default;\n\n owner.register(\"serializer:-rest\", _Serializer4);\n serializer = owner.lookup(\"serializer:-rest\");\n deprecateTestRegistration('serializer', '-rest');\n } else if (serializerName === '-default') {\n var _Serializer5 = require$1('@ember-data/serializer/json').default;\n\n owner.register(\"serializer:-default\", _Serializer5);\n serializer = owner.lookup(\"serializer:-default\");\n serializer && deprecateTestRegistration('serializer', '-default');\n }\n }\n\n if (serializer !== undefined) {\n Ember.set(serializer, 'store', this);\n _serializerCache[normalizedModelName] = serializer;\n _serializerCache[serializerName] = serializer;\n return serializer;\n }\n }\n\n {\n // final fallback, no model specific serializer, no application serializer, no\n // `serializer` property on store: use the convenience JSONSerializer\n serializer = _serializerCache['-default'] || owner.lookup('serializer:-default');\n\n if ( serializer === undefined) {\n var JSONSerializer = require$1('@ember-data/serializer/json').default;\n\n owner.register('serializer:-default', JSONSerializer);\n serializer = owner.lookup('serializer:-default');\n serializer && deprecateTestRegistration('serializer', '-default');\n }\n\n ( !(!serializer) && Ember.deprecate(\"store.serializerFor(\\\"\" + modelName + \"\\\") resolved the \\\"-default\\\" serializer via the deprecated \\\"-default\\\" lookup fallback.\\n\\n\\tPreviously, when no type-specific serializer, application serializer, or adapter.defaultSerializer had been defined by the app, the \\\"-default\\\" serializer would be used which defaulted to the `JSONSerializer`. This behavior is deprecated in favor of explicitly defining an application or type-specific serializer\", !serializer, {\n id: 'ember-data:default-serializer',\n until: '4.0',\n url: 'https://deprecations.emberjs.com/ember-data/v3.x/#toc_ember-data-default-serializers'\n }));\n ( !(serializer !== undefined) && Ember.assert(\"No serializer was found for '\" + modelName + \"' and no 'application' serializer was found as a fallback\", serializer !== undefined));\n Ember.set(serializer, 'store', this);\n _serializerCache[normalizedModelName] = serializer;\n _serializerCache['-default'] = serializer;\n return serializer;\n }\n };\n\n _proto.destroy = function destroy() {\n // enqueue destruction of any adapters/serializers we have created\n for (var adapterName in this._adapterCache) {\n var adapter = this._adapterCache[adapterName];\n\n if (typeof adapter.destroy === 'function') {\n adapter.destroy();\n }\n }\n\n for (var serializerName in this._serializerCache) {\n var serializer = this._serializerCache[serializerName];\n\n if (typeof serializer.destroy === 'function') {\n serializer.destroy();\n }\n }\n\n return _Ember$Service.prototype.destroy.call(this);\n };\n\n _proto.willDestroy = function willDestroy() {\n _Ember$Service.prototype.willDestroy.call(this);\n\n this.recordArrayManager.destroy();\n identifierCacheFor(this).destroy();\n this.unloadAll();\n\n {\n Ember.Test.unregisterWaiter(this.__asyncWaiter);\n var shouldTrack = this.shouldTrackAsyncRequests;\n var tracked = this._trackedAsyncRequests;\n var isSettled = tracked.length === 0;\n\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(function (o) {\n return o.label;\n }).join('\\n\\t - '));\n } else {\n ( Ember.warn('Async Request leaks detected. Add a breakpoint here and set `store.generateStackTracesForTrackedRequests = true;`to inspect traces for leak origins:\\n\\t - ' + tracked.map(function (o) {\n return o.label;\n }).join('\\n\\t - '), false, {\n id: 'ds.async.leak.detected'\n }));\n }\n }\n }\n };\n\n _proto._updateRelationshipState = function _updateRelationshipState(relationship) {\n var _this8 = this;\n\n if (this._updatedRelationships.push(relationship) !== 1) {\n return;\n }\n\n this._backburner.join(function () {\n _this8._backburner.schedule('syncRelationships', _this8, _this8._flushUpdatedRelationships);\n });\n };\n\n _proto._flushUpdatedRelationships = function _flushUpdatedRelationships() {\n var updated = this._updatedRelationships;\n\n for (var i = 0, l = updated.length; i < l; i++) {\n updated[i].flushCanonical();\n }\n\n updated.length = 0;\n };\n\n _proto._updateInternalModel = function _updateInternalModel(internalModel) {\n if (this._updatedInternalModels.push(internalModel) !== 1) {\n return;\n }\n\n emberRun$2.schedule('actions', this, this._flushUpdatedInternalModels);\n };\n\n _proto._flushUpdatedInternalModels = function _flushUpdatedInternalModels() {\n var updated = this._updatedInternalModels;\n\n for (var i = 0, l = updated.length; i < l; i++) {\n updated[i]._triggerDeferredTriggers();\n }\n\n updated.length = 0;\n };\n\n _createClass$8(CoreStore, [{\n key: \"identifierCache\",\n get: function get() {\n return identifierCacheFor(this);\n }\n }]);\n\n return CoreStore;\n }(Ember.Service);\n\n {\n Ember.defineProperty(CoreStore.prototype, 'defaultAdapter', Ember.computed('adapter', function () {\n ( Ember.deprecate(\"store.adapterFor(modelName) resolved the (\\\"\" + (this.adapter || '-json-api') + \"\\\") adapter via the deprecated `store.defaultAdapter` property.\\n\\n\\tPreviously, applications could define the store's `adapter` property which would be used by `defaultAdapter` and `adapterFor` as a fallback for when an adapter was not found by an exact name match. This behavior is deprecated in favor of explicitly defining an application or type-specific adapter.\", false, {\n id: 'ember-data:default-adapter',\n until: '4.0',\n url: 'https://deprecations.emberjs.com/ember-data/v3.x/#toc_ember-data-default-adapter'\n }));\n var adapter = this.adapter || '-json-api';\n ( !(typeof adapter === 'string') && Ember.assert('You tried to set `adapter` property to an instance of `Adapter`, where it should be a name', typeof adapter === 'string'));\n return this.adapterFor(adapter);\n }));\n }\n\n function _commit(adapter, store, operation, snapshot) {\n var internalModel = snapshot._internalModel;\n var modelName = snapshot.modelName;\n var modelClass = store.modelFor(modelName);\n ( !(adapter) && Ember.assert(\"You tried to update a record but you have no adapter (for \" + modelName + \")\", adapter));\n ( !(typeof adapter[operation] === 'function') && Ember.assert(\"You tried to update a record but your adapter (for \" + modelName + \") does not implement '\" + operation + \"'\", typeof adapter[operation] === 'function'));\n var promise = Ember.RSVP.Promise.resolve().then(function () {\n return adapter[operation](store, modelClass, snapshot);\n });\n var serializer = store.serializerFor(modelName);\n var label = \"DS: Extract and notify about \" + operation + \" completion of \" + internalModel;\n ( !(promise !== undefined) && Ember.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 return promise.then(function (adapterPayload) {\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 store._backburner.join(function () {\n var payload, data, sideloaded;\n\n if (adapterPayload) {\n payload = normalizeResponseHelper(serializer, store, modelClass, adapterPayload, snapshot.id, operation);\n\n if (payload.included) {\n sideloaded = payload.included;\n }\n\n data = payload.data;\n }\n\n store.didSaveRecord(internalModel, {\n data: data\n }, operation); // seems risky, but if the tests pass might be fine?\n\n if (sideloaded) {\n store._push({\n data: null,\n included: sideloaded\n });\n }\n });\n\n return internalModel;\n }, function (error) {\n if (error && error.isAdapterError === true && error.code === 'InvalidError') {\n var parsedErrors;\n\n if (typeof serializer.extractErrors === 'function') {\n parsedErrors = serializer.extractErrors(store, modelClass, error, snapshot.id);\n } else {\n parsedErrors = errorsArrayToHash(error.errors);\n }\n\n store.recordWasInvalid(internalModel, parsedErrors, error);\n } else {\n store.recordWasError(internalModel, error);\n }\n\n throw error;\n }, label);\n }\n\n var assertDestroyingStore;\n var assertDestroyedStoreOnly;\n\n {\n assertDestroyingStore = function assertDestroyedStore(store, method) {\n if (!store.shouldAssertMethodCallsOnDestroyedStore) {\n ( !(!(store.isDestroying || store.isDestroyed)) && Ember.deprecate(\"Attempted to call store.\" + method + \"(), but the store instance has already been destroyed.\", !(store.isDestroying || store.isDestroyed), {\n id: 'ember-data:method-calls-on-destroyed-store',\n until: '3.8'\n }));\n } else {\n ( !(!(store.isDestroying || store.isDestroyed)) && Ember.assert(\"Attempted to call store.\" + method + \"(), but the store instance has already been destroyed.\", !(store.isDestroying || store.isDestroyed)));\n }\n };\n\n assertDestroyedStoreOnly = function assertDestroyedStoreOnly(store, method) {\n if (!store.shouldAssertMethodCallsOnDestroyedStore) {\n ( !(!store.isDestroyed) && Ember.deprecate(\"Attempted to call store.\" + method + \"(), but the store instance has already been destroyed.\", !store.isDestroyed, {\n id: 'ember-data:method-calls-on-destroyed-store',\n until: '3.8'\n }));\n } else {\n ( !(!store.isDestroyed) && Ember.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 * @return {boolean}\n */\n\n\n function areAllInverseRecordsLoaded(store, resource) {\n var cache = identifierCacheFor(store);\n\n if (Array.isArray(resource.data)) {\n // treat as collection\n // check for unloaded records\n var hasEmptyRecords = resource.data.reduce(function (hasEmptyModel, resourceIdentifier) {\n return hasEmptyModel || internalModelForRelatedResource(store, cache, resourceIdentifier).isEmpty();\n }, false);\n return !hasEmptyRecords;\n } else {\n // treat as single resource\n if (!resource.data) {\n return true;\n } else {\n var internalModel = internalModelForRelatedResource(store, cache, resource.data);\n return !internalModel.isEmpty();\n }\n }\n }\n\n function internalModelForRelatedResource(store, cache, resource) {\n var identifier = cache.getOrCreateRecordIdentifier(resource);\n return store._internalModelForResource(identifier);\n }\n\n function assertInDebug(msg, cond) {\n if (cond === void 0) {\n cond = false;\n }\n\n if ( cond) {\n throw new Error(msg);\n }\n }\n\n function assertIdentifierHasId(identifier) {\n assertInDebug(\"Attempted to schedule a fetch for a record without an id.\", identifier.id === null);\n }\n\n function notifyChanges(identifier, value, record, store) {\n if (value === 'attributes') {\n record.eachAttribute(function (key) {\n var currentValue = Ember.cacheFor(record, key);\n\n var internalModel = store._internalModelForResource(identifier);\n\n if (currentValue !== internalModel._recordData.getAttr(key)) {\n record.notifyPropertyChange(key);\n }\n });\n } else if (value === 'relationships') {\n record.eachRelationship(function (key, meta) {\n var internalModel = store._internalModelForResource(identifier);\n\n if (meta.kind === 'belongsTo') {\n record.notifyPropertyChange(key);\n } else if (meta.kind === 'hasMany') {\n if (meta.options.async) {\n record.notifyPropertyChange(key);\n internalModel.hasManyRemovalCheck(key);\n }\n\n if (internalModel._manyArrayCache[key]) {\n internalModel._manyArrayCache[key].retrieveLatest();\n }\n }\n });\n } else if (value === 'errors') {\n var internalModel = store._internalModelForResource(identifier); //TODO guard\n\n\n var errors = internalModel._recordData.getErrors(identifier);\n\n record.invalidErrorsChanged(errors);\n } else if (value === 'state') {\n record.notifyPropertyChange('isNew');\n record.notifyPropertyChange('isDeleted');\n } else if (value === 'identity') {\n record.notifyPropertyChange('id');\n }\n }\n\n var _modelForMixin;\n\n {\n var _found$1;\n\n _modelForMixin = function _modelForMixin() {\n if (!_found$1) {\n _found$1 = require$1('@ember-data/model/-private')._modelForMixin;\n }\n\n return _found$1.apply(void 0, arguments);\n };\n }\n /**\n *\n * @param store\n * @param cache modelFactoryCache\n * @param normalizedModelName already normalized modelName\n * @return {*}\n */\n\n function getModelFactory(store, cache, normalizedModelName) {\n var factory = cache[normalizedModelName];\n\n if (!factory) {\n factory = _lookupModelFactory(store, normalizedModelName);\n\n if (!factory && true\n /* HAS_MODEL_PACKAGE */\n ) {\n //Support looking up mixins as base types for polymorphic relationships\n factory = _modelForMixin(store, normalizedModelName);\n }\n\n if (!factory) {\n // we don't cache misses in case someone wants to register a missing model\n return null;\n }\n\n var klass = factory.class;\n\n if (klass.isModel) {\n var hasOwnModelNameSet = klass.modelName && Object.prototype.hasOwnProperty.call(klass, 'modelName');\n\n if (!hasOwnModelNameSet) {\n Object.defineProperty(klass, 'modelName', {\n value: normalizedModelName\n });\n }\n }\n\n cache[normalizedModelName] = factory;\n }\n\n return factory;\n }\n function _lookupModelFactory(store, normalizedModelName) {\n var owner = Ember.getOwner(store);\n return owner.factoryFor(\"model:\" + normalizedModelName);\n }\n\n function _inheritsLoose$4(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf$4(subClass, superClass); }\n\n function _setPrototypeOf$4(o, p) { _setPrototypeOf$4 = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$4(o, p); }\n\n /**\n The store service 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 By default, applications will have a single `Store` service that is\n automatically created.\n\n The store can be customized by extending the service in the following manner:\n\n ```app/services/store.js\n import Store from '@ember-data/store';\n\n export default class MyStore extends Store {}\n ```\n\n You can retrieve models from the store in several ways. To retrieve a record\n for a specific id, use the `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 DS from 'ember-data';\n\n export default Adapter.extend({\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](../classes/Store/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](../classes/Store/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](../classes/Store/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 @class Store\n @main @ember-data/store\n @extends Ember.Service\n */\n var Store = /*#__PURE__*/function (_CoreStore) {\n _inheritsLoose$4(Store, _CoreStore);\n\n function Store() {\n var _this;\n\n for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n args[_key] = arguments[_key];\n }\n\n _this = _CoreStore.call.apply(_CoreStore, [this].concat(args)) || this;\n _this._modelFactoryCache = Object.create(null);\n _this._relationshipsDefCache = Object.create(null);\n _this._attributesDefCache = Object.create(null);\n return _this;\n }\n\n var _proto = Store.prototype;\n\n _proto.instantiateRecord = function instantiateRecord(identifier, createRecordArgs, recordDataFor, notificationManager) {\n var _this2 = this;\n\n var modelName = identifier.type;\n\n var internalModel = this._internalModelForResource(identifier);\n\n var createOptions = {\n store: this,\n _internalModel: internalModel,\n currentState: internalModel.currentState,\n container: null\n };\n Ember.assign(createOptions, createRecordArgs); // ensure that `getOwner(this)` works inside a model instance\n\n Ember.setOwner(createOptions, Ember.getOwner(this));\n delete createOptions.container;\n\n var record = this._modelFactoryFor(modelName).create(createOptions); //todo optimize\n\n\n notificationManager.subscribe(identifier, function (identifier, value) {\n return notifyChanges(identifier, value, record, _this2);\n });\n return record;\n };\n\n _proto.teardownRecord = function teardownRecord(record) {\n record.destroy();\n }\n /**\n Returns the model class for the particular `modelName`.\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 @param {String} modelName\n @return {Model}\n */\n ;\n\n _proto.modelFor = function modelFor(modelName) {\n {\n assertDestroyedStoreOnly$1(this, 'modelFor');\n }\n\n ( !(Ember.isPresent(modelName)) && Ember.assert(\"You need to pass a model name to the store's modelFor method\", Ember.isPresent(modelName)));\n ( !(typeof modelName === 'string') && Ember.assert(\"Passing classes to store methods has been removed. Please pass a dasherized string instead of \" + modelName, typeof modelName === 'string'));\n\n var maybeFactory = this._modelFactoryFor(modelName); // for factorFor factory/class split\n\n\n var klass = maybeFactory && maybeFactory.class ? maybeFactory.class : maybeFactory;\n\n if (!klass || !klass.isModel) {\n {\n throw new Ember.Error(\"No model was found for '\" + modelName + \"' and no schema handles the type\");\n }\n } else {\n return klass;\n }\n };\n\n _proto._modelFactoryFor = function _modelFactoryFor(modelName) {\n {\n assertDestroyedStoreOnly$1(this, '_modelFactoryFor');\n }\n\n ( !(Ember.isPresent(modelName)) && Ember.assert(\"You need to pass a model name to the store's _modelFactoryFor method\", Ember.isPresent(modelName)));\n ( !(typeof modelName === 'string') && Ember.assert(\"Passing classes to store methods has been removed. Please pass a dasherized string instead of \" + modelName, typeof modelName === 'string'));\n var normalizedModelName = normalizeModelName(modelName);\n var factory = getModelFactory(this, this._modelFactoryCache, normalizedModelName);\n return factory;\n }\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 @private\n */\n ;\n\n _proto._hasModelFor = function _hasModelFor(modelName) {\n {\n assertDestroyingStore$1(this, '_hasModelFor');\n }\n\n ( !(Ember.isPresent(modelName)) && Ember.assert(\"You need to pass a model name to the store's hasModelFor method\", Ember.isPresent(modelName)));\n ( !(typeof modelName === 'string') && Ember.assert(\"Passing classes to store methods has been removed. Please pass a dasherized string instead of \" + modelName, typeof modelName === 'string'));\n\n {\n ( !(Ember.isPresent(modelName)) && Ember.assert(\"You need to pass a model name to the store's hasModelFor method\", Ember.isPresent(modelName)));\n ( !(typeof modelName === 'string') && Ember.assert(\"Passing classes to store methods has been removed. Please pass a dasherized string instead of \" + modelName, typeof modelName === 'string'));\n var normalizedModelName = normalizeModelName(modelName);\n var factory = getModelFactory(this, this._modelFactoryCache, normalizedModelName);\n return factory !== null;\n }\n };\n\n _proto._relationshipMetaFor = function _relationshipMetaFor(modelName, id, key) {\n {\n var modelClass = this.modelFor(modelName);\n var relationshipsByName = Ember.get(modelClass, 'relationshipsByName');\n return relationshipsByName.get(key);\n }\n };\n\n _proto._attributesDefinitionFor = function _attributesDefinitionFor(modelName, identifier) {\n {\n var attributes = this._attributesDefCache[modelName];\n\n if (attributes === undefined) {\n var modelClass = this.modelFor(modelName);\n var attributeMap = Ember.get(modelClass, 'attributes');\n attributes = Object.create(null);\n attributeMap.forEach(function (meta, name) {\n return attributes[name] = meta;\n });\n this._attributesDefCache[modelName] = attributes;\n }\n\n return attributes;\n }\n };\n\n _proto._relationshipsDefinitionFor = function _relationshipsDefinitionFor(modelName, identifier) {\n {\n var relationships = this._relationshipsDefCache[modelName];\n\n if (relationships === undefined) {\n var modelClass = this.modelFor(modelName);\n relationships = Ember.get(modelClass, 'relationshipsObject') || null;\n this._relationshipsDefCache[modelName] = relationships;\n }\n\n return relationships;\n }\n };\n\n _proto.getSchemaDefinitionService = function getSchemaDefinitionService() {\n {\n throw 'schema service is only available when custom model class feature flag is on';\n }\n };\n\n return Store;\n }(CoreStore);\n\n var assertDestroyingStore$1;\n var assertDestroyedStoreOnly$1;\n\n {\n assertDestroyingStore$1 = function assertDestroyedStore(store, method) {\n if (!store.shouldAssertMethodCallsOnDestroyedStore) {\n ( !(!(store.isDestroying || store.isDestroyed)) && Ember.deprecate(\"Attempted to call store.\" + method + \"(), but the store instance has already been destroyed.\", !(store.isDestroying || store.isDestroyed), {\n id: 'ember-data:method-calls-on-destroyed-store',\n until: '3.8'\n }));\n } else {\n ( !(!(store.isDestroying || store.isDestroyed)) && Ember.assert(\"Attempted to call store.\" + method + \"(), but the store instance has already been destroyed.\", !(store.isDestroying || store.isDestroyed)));\n }\n };\n\n assertDestroyedStoreOnly$1 = function assertDestroyedStoreOnly(store, method) {\n if (!store.shouldAssertMethodCallsOnDestroyedStore) {\n ( !(!store.isDestroyed) && Ember.deprecate(\"Attempted to call store.\" + method + \"(), but the store instance has already been destroyed.\", !store.isDestroyed, {\n id: 'ember-data:method-calls-on-destroyed-store',\n until: '3.8'\n }));\n } else {\n ( !(!store.isDestroyed) && Ember.assert(\"Attempted to call store.\" + method + \"(), but the store instance has already been destroyed.\", !store.isDestroyed));\n }\n };\n }\n\n /**\n @module @ember-data/store\n */\n\n /**\n @method diffArray\n @private\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 var oldLength = oldArray.length;\n var newLength = newArray.length;\n var shortestLength = Math.min(oldLength, newLength);\n var firstChangeIndex = null; // null signifies no changes\n // find the first change\n\n for (var 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\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\n var addedCount = 0;\n var removedCount = 0;\n\n if (firstChangeIndex !== null) {\n // we found a change, find the end of the change\n var unchangedEndBlockLength = shortestLength - firstChangeIndex; // walk back from the end of both arrays until we find a change\n\n for (var _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\n addedCount = newLength - unchangedEndBlockLength - firstChangeIndex;\n removedCount = oldLength - unchangedEndBlockLength - firstChangeIndex;\n }\n\n return {\n firstChangeIndex: firstChangeIndex,\n addedCount: addedCount,\n removedCount: removedCount\n };\n }\n\n function _defineProperties$9(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\n function _createClass$9(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$9(Constructor.prototype, protoProps); if (staticProps) _defineProperties$9(Constructor, staticProps); return Constructor; }\n\n /**\n @module @ember-data/store\n */\n function typeForRelationshipMeta(meta) {\n var modelName;\n modelName = meta.type || meta.key;\n modelName = normalizeModelName(modelName);\n\n if (meta.kind === 'hasMany') {\n modelName = emberInflector.singularize(modelName);\n }\n\n return modelName;\n }\n\n function shouldFindInverse(relationshipMeta) {\n var options = relationshipMeta.options;\n return !(options && options.inverse === null);\n }\n\n var RelationshipDefinition = /*#__PURE__*/function () {\n function RelationshipDefinition(meta) {\n this[BRAND_SYMBOL] = void 0;\n this._type = '';\n this.__inverseKey = '';\n this.__inverseIsAsync = true;\n this.__hasCalculatedInverse = false;\n this.parentModelName = void 0;\n this.inverse = void 0;\n this.inverseIsAsync = void 0;\n this.meta = meta;\n this.parentModelName = meta.parentModelName;\n }\n\n var _proto = RelationshipDefinition.prototype;\n\n _proto._inverseKey = function _inverseKey(store, modelClass) {\n if (this.__hasCalculatedInverse === false) {\n this._calculateInverse(store, modelClass);\n }\n\n return this.__inverseKey;\n };\n\n _proto._inverseIsAsync = function _inverseIsAsync(store, modelClass) {\n if (this.__hasCalculatedInverse === false) {\n this._calculateInverse(store, modelClass);\n }\n\n return this.__inverseIsAsync;\n };\n\n _proto._calculateInverse = function _calculateInverse(store, modelClass) {\n this.__hasCalculatedInverse = true;\n var inverseKey, inverseIsAsync;\n var inverse = null;\n\n if (shouldFindInverse(this.meta)) {\n inverse = modelClass.inverseFor(this.key, store);\n } else {\n modelClass.typeForRelationship(this.key, store);\n }\n\n if (inverse) {\n inverseKey = inverse.name;\n inverseIsAsync = isInverseAsync(inverse);\n } else {\n inverseKey = null;\n inverseIsAsync = false;\n }\n\n this.__inverseKey = inverseKey;\n this.__inverseIsAsync = inverseIsAsync;\n };\n\n _createClass$9(RelationshipDefinition, [{\n key: \"key\",\n get: function get() {\n return this.meta.key;\n }\n }, {\n key: \"kind\",\n get: function get() {\n return this.meta.kind;\n }\n }, {\n key: \"type\",\n get: function get() {\n if (this._type) {\n return this._type;\n }\n\n this._type = typeForRelationshipMeta(this.meta);\n return this._type;\n }\n }, {\n key: \"options\",\n get: function get() {\n return this.meta.options;\n }\n }, {\n key: \"name\",\n get: function get() {\n return this.meta.name;\n }\n }]);\n\n return RelationshipDefinition;\n }();\n\n function isInverseAsync(meta) {\n var inverseAsync = meta.options && meta.options.async;\n return typeof inverseAsync === 'undefined' ? true : inverseAsync;\n }\n\n function relationshipFromMeta(meta) {\n return new RelationshipDefinition(meta);\n }\n\n exports.AdapterPopulatedRecordArray = AdapterPopulatedRecordArray;\n exports.DeprecatedEvented = DeprecatedEvented$1;\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._bind = _bind;\n exports._guard = _guard;\n exports._objectIsAlive = _objectIsAlive;\n exports.addSymbol = addSymbol;\n exports.coerceId = coerceId;\n exports.diffArray = diffArray;\n exports.errorsArrayToHash = errorsArrayToHash;\n exports.errorsHashToArray = errorsHashToArray;\n exports.guardDestroyedStore = guardDestroyedStore;\n exports.identifierCacheFor = identifierCacheFor;\n exports.normalizeModelName = normalizeModelName;\n exports.recordDataFor = recordDataFor;\n exports.recordIdentifierFor = recordIdentifierFor;\n exports.relationshipFromMeta = relationshipFromMeta;\n exports.setIdentifierForgetMethod = setIdentifierForgetMethod;\n exports.setIdentifierGenerationMethod = setIdentifierGenerationMethod;\n exports.setIdentifierResetMethod = setIdentifierResetMethod;\n exports.setIdentifierUpdateMethod = setIdentifierUpdateMethod;\n exports.symbol = symbol;\n exports.typeForRelationshipMeta = typeForRelationshipMeta;\n exports.upgradeForInternal = upgradeForInternal;\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 get() {\n return _private.Store;\n }\n });\n Object.defineProperty(_exports, \"normalizeModelName\", {\n enumerable: true,\n get: function get() {\n return _private.normalizeModelName;\n }\n });\n Object.defineProperty(_exports, \"setIdentifierGenerationMethod\", {\n enumerable: true,\n get: function get() {\n return _private.setIdentifierGenerationMethod;\n }\n });\n Object.defineProperty(_exports, \"setIdentifierUpdateMethod\", {\n enumerable: true,\n get: function get() {\n return _private.setIdentifierUpdateMethod;\n }\n });\n Object.defineProperty(_exports, \"setIdentifierForgetMethod\", {\n enumerable: true,\n get: function get() {\n return _private.setIdentifierForgetMethod;\n }\n });\n Object.defineProperty(_exports, \"setIdentifierResetMethod\", {\n enumerable: true,\n get: function get() {\n return _private.setIdentifierResetMethod;\n }\n });\n Object.defineProperty(_exports, \"recordIdentifierFor\", {\n enumerable: true,\n get: function get() {\n return _private.recordIdentifierFor;\n }\n });\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.isFieldDescriptor = isFieldDescriptor;\n _exports.isDescriptor = isDescriptor;\n\n function _typeof(obj) { \"@babel/helpers - typeof\"; if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\n function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\n\n function _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\n function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\n function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\n function _iterableToArrayLimit(arr, i) { if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"] != null) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; }\n\n function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\n\n function isClassDescriptor(possibleDesc) {\n var _possibleDesc = _slicedToArray(possibleDesc, 1),\n target = _possibleDesc[0];\n\n return possibleDesc.length === 1 && typeof target === 'function' && 'prototype' in target && !target.__isComputedDecorator;\n }\n\n function isFieldDescriptor(possibleDesc) {\n var _possibleDesc2 = _slicedToArray(possibleDesc, 3),\n target = _possibleDesc2[0],\n key = _possibleDesc2[1],\n desc = _possibleDesc2[2];\n\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\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\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-decorators/utils/-private/class-field-descriptor\"], function (_exports, _classFieldDescriptor) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.decoratorWithParams = decoratorWithParams;\n _exports.decoratorWithRequiredParams = decoratorWithRequiredParams;\n\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 () {\n for (var _len = arguments.length, params = new Array(_len), _key = 0; _key < _len; _key++) {\n params[_key] = arguments[_key];\n }\n\n // determine if user called as @computed('blah', 'blah') or @computed\n if ((0, _classFieldDescriptor.isDescriptor)(params)) {\n return fn.apply(void 0, params);\n } else {\n return function () {\n for (var _len2 = arguments.length, desc = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n desc[_key2] = arguments[_key2];\n }\n\n return fn.apply(void 0, desc.concat([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\n\n function decoratorWithRequiredParams(fn, name) {\n return function () {\n for (var _len3 = arguments.length, params = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {\n params[_key3] = arguments[_key3];\n }\n\n (true && !(!(0, _classFieldDescriptor.isDescriptor)(params) && params.length > 0) && Ember.assert(\"The @\".concat(name || fn.name, \" decorator requires parameters\"), !(0, _classFieldDescriptor.isDescriptor)(params) && params.length > 0));\n return function () {\n for (var _len4 = arguments.length, desc = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {\n desc[_key4] = arguments[_key4];\n }\n\n return fn.apply(void 0, desc.concat([params]));\n };\n };\n }\n});","define(\"@ember/ordered-set/index\", [\"exports\"], function (_exports) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.default = void 0;\n var NEEDS_CUSTOM_ORDERED_SET = true;\n var OrderedSet;\n\n if (NEEDS_CUSTOM_ORDERED_SET) {\n /**\n @class OrderedSet\n @constructor\n */\n OrderedSet = /*#__PURE__*/function () {\n function OrderedSet() {\n this.clear();\n }\n /**\n @method create\n @static\n @return {OrderedSet}\n */\n\n\n OrderedSet.create = function create() {\n var Constructor = this;\n return new Constructor();\n }\n /**\n @method clear\n */\n ;\n\n var _proto = OrderedSet.prototype;\n\n _proto.clear = function clear() {\n this.presenceSet = Object.create(null);\n this.list = [];\n this.size = 0;\n }\n /**\n @method add\n @param {*} obj\n @param {string} [_guid] (for internal use)\n @return {OrderedSet}\n */\n ;\n\n _proto.add = function add(obj, _guid) {\n var guid = _guid || Ember.guidFor(obj);\n\n var presenceSet = this.presenceSet;\n var list = this.list;\n\n if (presenceSet[guid] !== true) {\n presenceSet[guid] = true;\n this.size = list.push(obj);\n }\n\n return this;\n }\n /**\n @method delete\n @param {*} obj\n @param {string} [_guid] (for internal use)\n @return {Boolean}\n */\n ;\n\n _proto.delete = function _delete(obj, _guid) {\n var guid = _guid || Ember.guidFor(obj);\n\n var presenceSet = this.presenceSet;\n var list = this.list;\n\n if (presenceSet[guid] === true) {\n delete presenceSet[guid];\n var index = list.indexOf(obj);\n\n if (index > -1) {\n list.splice(index, 1);\n }\n\n this.size = list.length;\n return true;\n } else {\n return false;\n }\n }\n /**\n @method isEmpty\n @return {Boolean}\n */\n ;\n\n _proto.isEmpty = function isEmpty() {\n return this.size === 0;\n }\n /**\n @method has\n @param {*} obj\n @return {Boolean}\n */\n ;\n\n _proto.has = function has(obj) {\n if (this.size === 0) {\n return false;\n }\n\n var guid = Ember.guidFor(obj);\n var presenceSet = this.presenceSet;\n return presenceSet[guid] === true;\n }\n /**\n @method forEach\n @param {Function} fn\n @param self\n */\n ;\n\n _proto.forEach = function forEach(fn\n /*, ...thisArg*/\n ) {\n (true && !(typeof fn === 'function') && Ember.assert(Object.prototype.toString.call(fn) + \" is not a function\", typeof fn === 'function'));\n\n if (this.size === 0) {\n return;\n }\n\n var list = this.list;\n\n if (arguments.length === 2) {\n for (var i = 0; i < list.length; i++) {\n fn.call(arguments[1], list[i]);\n }\n } else {\n for (var _i = 0; _i < list.length; _i++) {\n fn(list[_i]);\n }\n }\n }\n /**\n @method toArray\n @return {Array}\n */\n ;\n\n _proto.toArray = function toArray() {\n return this.list.slice();\n }\n /**\n @method copy\n @return {OrderedSet}\n */\n ;\n\n _proto.copy = function copy() {\n var Constructor = this.constructor;\n var set = new Constructor();\n set.presenceSet = Object.create(null);\n\n for (var prop in this.presenceSet) {\n // hasOwnPropery is not needed because obj is Object.create(null);\n set.presenceSet[prop] = this.presenceSet[prop];\n }\n\n set.list = this.toArray();\n set.size = this.size;\n return set;\n };\n\n return OrderedSet;\n }();\n } else {\n OrderedSet = Ember.__OrderedSet__ || Ember.OrderedSet;\n }\n\n var _default = OrderedSet;\n _exports.default = _default;\n});","define(\"@ember/render-modifiers/modifiers/did-insert\", [\"exports\"], function (_exports) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.default = void 0;\n\n function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n function _toArray(arr) { return _arrayWithHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableRest(); }\n\n function _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\n function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\n function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\n function _iterableToArray(iter) { if (typeof Symbol !== \"undefined\" && Symbol.iterator in Object(iter)) return Array.from(iter); }\n\n function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\n\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 = Ember._setModifierManager(function () {\n return {\n capabilities: Ember._modifierManagerCapabilities('3.13', {\n disableAutoTracking: true\n }),\n createModifier: function createModifier() {},\n installModifier: function installModifier(_state, element, args) {\n var _args$positional = _toArray(args.positional),\n fn = _args$positional[0],\n positional = _args$positional.slice(1);\n\n fn(element, positional, args.named);\n },\n updateModifier: function updateModifier() {},\n destroyModifier: function destroyModifier() {}\n };\n }, function DidInsertModifier() {\n _classCallCheck(this, DidInsertModifier);\n });\n\n _exports.default = _default;\n});","define(\"@ember/render-modifiers/modifiers/did-update\", [\"exports\"], function (_exports) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.default = void 0;\n\n function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n function _toArray(arr) { return _arrayWithHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableRest(); }\n\n function _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\n function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\n function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\n function _iterableToArray(iter) { if (typeof Symbol !== \"undefined\" && Symbol.iterator in Object(iter)) return Array.from(iter); }\n\n function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\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 = Ember._setModifierManager(function () {\n return {\n capabilities: Ember._modifierManagerCapabilities('3.13', {\n disableAutoTracking: true\n }),\n createModifier: function createModifier() {\n return {\n element: null\n };\n },\n installModifier: function installModifier(state, element) {\n // save element into state bucket\n state.element = element;\n },\n updateModifier: function updateModifier(_ref, args) {\n var element = _ref.element;\n\n var _args$positional = _toArray(args.positional),\n fn = _args$positional[0],\n positional = _args$positional.slice(1);\n\n fn(element, positional, args.named);\n },\n destroyModifier: function destroyModifier() {}\n };\n }, function DidUpdateModifier() {\n _classCallCheck(this, DidUpdateModifier);\n });\n\n _exports.default = _default;\n});","define(\"@ember/render-modifiers/modifiers/will-destroy\", [\"exports\"], function (_exports) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.default = void 0;\n\n function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n function _toArray(arr) { return _arrayWithHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableRest(); }\n\n function _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\n function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\n function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\n function _iterableToArray(iter) { if (typeof Symbol !== \"undefined\" && Symbol.iterator in Object(iter)) return Array.from(iter); }\n\n function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\n\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 = Ember._setModifierManager(function () {\n return {\n capabilities: Ember._modifierManagerCapabilities('3.13', {\n disableAutoTracking: true\n }),\n createModifier: function createModifier() {\n return {\n element: null\n };\n },\n installModifier: function installModifier(state, element) {\n state.element = element;\n },\n updateModifier: function updateModifier() {},\n destroyModifier: function destroyModifier(_ref, args) {\n var element = _ref.element;\n\n var _args$positional = _toArray(args.positional),\n fn = _args$positional[0],\n positional = _args$positional.slice(1);\n\n fn(element, positional, args.named);\n }\n };\n }, function WillDestroyModifier() {\n _classCallCheck(this, WillDestroyModifier);\n });\n\n _exports.default = _default;\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\n function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\n function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }\n\n var UNDEFINED = function UNDEFINED() {};\n\n var Cache = /*#__PURE__*/function () {\n function Cache(limit, func, key, store) {\n _classCallCheck(this, Cache);\n\n this.size = 0;\n this.misses = 0;\n this.hits = 0;\n this.limit = limit;\n this.func = func;\n this.key = key;\n this.store = store || new DefaultStore();\n }\n\n _createClass(Cache, [{\n key: \"get\",\n value: function get(obj) {\n var key = this.key === undefined ? obj : this.key(obj);\n var value = this.store.get(key);\n\n if (value === undefined) {\n this.misses++;\n value = this._set(key, this.func(obj));\n } else if (value === UNDEFINED) {\n this.hits++;\n value = undefined;\n } else {\n this.hits++; // nothing to translate\n }\n\n return value;\n }\n }, {\n key: \"set\",\n value: function set(obj, value) {\n var key = this.key === undefined ? obj : this.key(obj);\n return this._set(key, value);\n }\n }, {\n key: \"_set\",\n value: function _set(key, value) {\n if (this.limit > this.size) {\n this.size++;\n\n if (value === undefined) {\n this.store.set(key, UNDEFINED);\n } else {\n this.store.set(key, value);\n }\n }\n\n return value;\n }\n }, {\n key: \"purge\",\n value: function purge() {\n this.store.clear();\n this.size = 0;\n this.hits = 0;\n this.misses = 0;\n }\n }]);\n\n return Cache;\n }();\n\n _exports.default = Cache;\n\n var DefaultStore = /*#__PURE__*/function () {\n function DefaultStore() {\n _classCallCheck(this, DefaultStore);\n\n this.data = Object.create(null);\n }\n\n _createClass(DefaultStore, [{\n key: \"get\",\n value: function get(key) {\n return this.data[key];\n }\n }, {\n key: \"set\",\n value: function set(key, value) {\n this.data[key] = value;\n }\n }, {\n key: \"clear\",\n value: function clear() {\n this.data = Object.create(null);\n }\n }]);\n\n return DefaultStore;\n }();\n});","define(\"@ember/string/helpers/loc\", [\"exports\"], function (_exports) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.loc = loc;\n _exports.default = void 0;\n\n function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }\n\n function _nonIterableSpread() { throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\n function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\n function _iterableToArray(iter) { if (typeof Symbol !== \"undefined\" && Symbol.iterator in Object(iter)) return Array.from(iter); }\n\n function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }\n\n function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\n function loc(params\n /*, hash*/\n ) {\n var _Ember$String;\n\n return (_Ember$String = Ember.String).loc.apply(_Ember$String, _toConsumableArray(params));\n }\n\n var _default = Ember.Helper.helper(loc);\n\n _exports.default = _default;\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.setStrings = setStrings;\n _exports.getStrings = getStrings;\n _exports.getString = getString;\n _exports.loc = loc;\n _exports.w = w;\n _exports.decamelize = decamelize;\n _exports.dasherize = dasherize;\n _exports.camelize = camelize;\n _exports.classify = classify;\n _exports.underscore = underscore;\n _exports.capitalize = capitalize;\n\n /**\n @module ember\n @submodule ember-runtime\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 var STRINGS = {};\n\n function setStrings(strings) {\n STRINGS = strings;\n }\n\n function getStrings() {\n return STRINGS;\n }\n\n function getString(name) {\n return STRINGS[name];\n }\n\n var STRING_DASHERIZE_REGEXP = /[ _]/g;\n var STRING_DASHERIZE_CACHE = new _cache.default(1000, function (key) {\n return decamelize(key).replace(STRING_DASHERIZE_REGEXP, '-');\n });\n var STRING_CAMELIZE_REGEXP_1 = /(-|_|\\.|\\s)+(.)?/g;\n var STRING_CAMELIZE_REGEXP_2 = /(^|\\/)([A-Z])/g;\n var CAMELIZE_CACHE = new _cache.default(1000, function (key) {\n return key.replace(STRING_CAMELIZE_REGEXP_1, function (match, separator, chr) {\n return chr ? chr.toUpperCase() : '';\n }).replace(STRING_CAMELIZE_REGEXP_2, function (match\n /*, separator, chr*/\n ) {\n return match.toLowerCase();\n });\n });\n var STRING_CLASSIFY_REGEXP_1 = /^(-|_)+(.)?/;\n var STRING_CLASSIFY_REGEXP_2 = /(.)(-|_|\\.|\\s)+(.)?/g;\n var STRING_CLASSIFY_REGEXP_3 = /(^|\\/|\\.)([a-z])/g;\n var CLASSIFY_CACHE = new _cache.default(1000, function (str) {\n var replace1 = function replace1(match, separator, chr) {\n return chr ? \"_\".concat(chr.toUpperCase()) : '';\n };\n\n var replace2 = function replace2(match, initialChar, separator, chr) {\n return initialChar + (chr ? chr.toUpperCase() : '');\n };\n\n var parts = str.split('/');\n\n for (var 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\n return parts.join('/').replace(STRING_CLASSIFY_REGEXP_3, function (match\n /*, separator, chr*/\n ) {\n return match.toUpperCase();\n });\n });\n var STRING_UNDERSCORE_REGEXP_1 = /([a-z\\d])([A-Z]+)/g;\n var STRING_UNDERSCORE_REGEXP_2 = /-|\\s+/g;\n var UNDERSCORE_CACHE = new _cache.default(1000, function (str) {\n return str.replace(STRING_UNDERSCORE_REGEXP_1, '$1_$2').replace(STRING_UNDERSCORE_REGEXP_2, '_').toLowerCase();\n });\n var STRING_CAPITALIZE_REGEXP = /(^|\\/)([a-z\\u00C0-\\u024F])/g;\n var CAPITALIZE_CACHE = new _cache.default(1000, function (str) {\n return str.replace(STRING_CAPITALIZE_REGEXP, function (match\n /*, separator, chr*/\n ) {\n return match.toUpperCase();\n });\n });\n var STRING_DECAMELIZE_REGEXP = /([a-z\\d])([A-Z])/g;\n var DECAMELIZE_CACHE = new _cache.default(1000, function (str) {\n return str.replace(STRING_DECAMELIZE_REGEXP, '$1_$2').toLowerCase();\n });\n\n function _fmt(str, formats) {\n // first, replace any ORDERED replacements.\n var idx = 0; // the current index for non-numerical replacements\n\n return str.replace(/%@([0-9]+)?/g, function (_s, argIndex) {\n var i = argIndex ? parseInt(argIndex, 10) - 1 : idx++;\n var r = i < formats.length ? formats[i] : undefined;\n return typeof r === 'string' ? r : r === null ? '(null)' : r === undefined ? '' : String(r);\n });\n }\n /**\n Formats the passed string, but first looks up the string in the localized\n strings hash. This is a convenient way to localize text. See\n `fmt` for more information on formatting.\n \n Note that it is traditional but not required to prefix localized string\n keys with an underscore or other character so you can easily identify\n localized strings.\n \n ```javascript\n import { setStrings, loc } from \"@ember/string\";\n \n setStrings({\n \"_Hello World\": \"Bonjour le monde\",\n \"_Hello %@ %@\": \"Bonjour %@ %@\"\n });\n \n loc(\"_Hello World\"); // 'Bonjour le monde';\n loc(\"_Hello %@ %@\", [\"John\", \"Smith\"]); // \"Bonjour John Smith\";\n ```\n \n @method loc\n @param {String} str The string to format\n @param {Array} formats Optional array of parameters to interpolate into string.\n @return {String} formatted string\n @public\n */\n\n\n function loc(str, formats) {\n (true && !(false) && Ember.deprecate('loc is deprecated, use an internationalization or localization addon instead.', false, {\n id: 'ember-string-loc',\n until: '2.0.0',\n url: 'http://emberjs.com/deprecations/v2.x#toc_ember-string-loc'\n }));\n\n if (!Array.isArray(formats) || arguments.length > 2) {\n formats = Array.prototype.slice.call(arguments, 1);\n }\n\n str = STRINGS[str] || str;\n return _fmt(str, formats);\n }\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 Ember.String.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\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 'innerHTML'.decamelize(); // 'inner_html'\n 'action_name'.decamelize(); // 'action_name'\n 'css-class-name'.decamelize(); // 'css-class-name'\n 'my favorite items'.decamelize(); // '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\n function decamelize(str) {\n return DECAMELIZE_CACHE.get(str);\n }\n /**\n Replaces underscores, spaces, or camelCase with dashes.\n \n ```javascript\n 'innerHTML'.dasherize(); // 'inner-html'\n 'action_name'.dasherize(); // 'action-name'\n 'css-class-name'.dasherize(); // 'css-class-name'\n 'my favorite items'.dasherize(); // 'my-favorite-items'\n 'privateDocs/ownerInvoice'.dasherize(); // '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\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 'innerHTML'.camelize(); // 'innerHTML'\n 'action_name'.camelize(); // 'actionName'\n 'css-class-name'.camelize(); // 'cssClassName'\n 'my favorite items'.camelize(); // 'myFavoriteItems'\n 'My Favorite Items'.camelize(); // 'myFavoriteItems'\n 'private-docs/owner-invoice'.camelize(); // '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\n function camelize(str) {\n return CAMELIZE_CACHE.get(str);\n }\n /**\n Returns the UpperCamelCase form of a string.\n \n ```javascript\n 'innerHTML'.classify(); // 'InnerHTML'\n 'action_name'.classify(); // 'ActionName'\n 'css-class-name'.classify(); // 'CssClassName'\n 'my favorite items'.classify(); // 'MyFavoriteItems'\n 'private-docs/owner-invoice'.classify(); // '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\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 'innerHTML'.underscore(); // 'inner_html'\n 'action_name'.underscore(); // 'action_name'\n 'css-class-name'.underscore(); // 'css_class_name'\n 'my favorite items'.underscore(); // 'my_favorite_items'\n 'privateDocs/ownerInvoice'.underscore(); // '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\n function underscore(str) {\n return UNDERSCORE_CACHE.get(str);\n }\n /**\n Returns the Capitalized form of a string\n \n ```javascript\n 'innerHTML'.capitalize() // 'InnerHTML'\n 'action_name'.capitalize() // 'Action_name'\n 'css-class-name'.capitalize() // 'Css-class-name'\n 'my favorite items'.capitalize() // 'My favorite items'\n 'privateDocs/ownerInvoice'.capitalize(); // '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\n function capitalize(str) {\n return CAPITALIZE_CACHE.get(str);\n }\n});","define(\"@embroider/macros/runtime\", [\"exports\"], function (_exports) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.each = each;\n _exports.macroCondition = macroCondition;\n _exports.config = config;\n _exports.getGlobalConfig = getGlobalConfig;\n _exports.isTesting = isTesting;\n\n function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === \"undefined\" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }\n\n function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\n function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\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 function each(array) {\n if (!Array.isArray(array)) {\n throw new Error(\"the argument to the each() macro must be an array\");\n }\n\n return array;\n }\n\n function macroCondition(predicate) {\n return predicate;\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\n\n function config(packageRoot) {\n return runtimeConfig.packages[packageRoot];\n }\n\n function getGlobalConfig() {\n return runtimeConfig.global;\n }\n\n function isTesting() {\n var g = runtimeConfig.global;\n var e = g && g['@embroider/macros'];\n return Boolean(e && e.isTesting);\n }\n\n var runtimeConfig = initializeRuntimeMacrosConfig(); // this exists to be targeted by our babel plugin\n\n function initializeRuntimeMacrosConfig() {\n return {\n \"packages\": {},\n \"global\": {\n \"@embroider/macros\": {\n \"isTesting\": false\n }\n }\n };\n }\n\n function updaterMethods() {\n return {\n config: config,\n getGlobalConfig: getGlobalConfig,\n setConfig: function setConfig(packageRoot, value) {\n runtimeConfig.packages[packageRoot] = value;\n },\n setGlobalConfig: function setGlobalConfig(key, value) {\n runtimeConfig.global[key] = value;\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\n\n var updaters = typeof window !== 'undefined' ? window._embroider_macros_runtime_config : undefined;\n\n if (updaters) {\n var methods = updaterMethods();\n\n var _iterator = _createForOfIteratorHelper(updaters),\n _step;\n\n try {\n for (_iterator.s(); !(_step = _iterator.n()).done;) {\n var updater = _step.value;\n updater(methods);\n }\n } catch (err) {\n _iterator.e(err);\n } finally {\n _iterator.f();\n }\n }\n});","define(\"@embroider/util/ember-private-api\", [\"exports\", \"@embroider/macros/runtime\"], function (_exports, _runtime) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.lookupCurriedComponentDefinition = lookupCurriedComponentDefinition;\n _exports.isCurriedComponentDefinition = void 0;\n\n /* global Ember */\n var _Ember$__loader$requi = Ember.__loader.require('@glimmer/runtime'),\n isCurriedComponentDefinition = _Ember$__loader$requi.isCurriedComponentDefinition,\n CurriedComponentDefinition = _Ember$__loader$requi.CurriedComponentDefinition,\n curry = _Ember$__loader$requi.curry,\n CurriedValue = _Ember$__loader$requi.CurriedValue; // older embers have isCurriedComponentDefinition, new ones have CurriedValue\n // and instanceof CurriedValue seems good enough.\n\n\n _exports.isCurriedComponentDefinition = isCurriedComponentDefinition;\n\n if (!isCurriedComponentDefinition) {\n _exports.isCurriedComponentDefinition = isCurriedComponentDefinition = function isCurriedComponentDefinition(value) {\n return value instanceof CurriedValue;\n };\n }\n\n function runtimeResolver(owner) {\n var resolver = owner.lookup('renderer:-dom')._runtimeResolver;\n\n if (resolver) {\n return resolver;\n }\n\n var entry = Object.entries(owner.__container__.cache).find(function (e) {\n return e[0].startsWith('template-compiler:main-');\n });\n\n if (entry) {\n return entry[1].resolver.resolver;\n }\n\n throw new Error(\"@embroider/util couldn't locate the runtime resolver on this ember version\");\n }\n\n function lookupCurriedComponentDefinition(name, owner) {\n var resolver = runtimeResolver(owner);\n\n if (typeof resolver.lookupComponentHandle === 'function') {\n var handle = resolver.lookupComponentHandle(name, contextForLookup(owner));\n\n if (handle != null) {\n return new CurriedComponentDefinition(resolver.resolve(handle), null);\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\n\n var resolvedDefinition = resolver.lookupComponent(name, owner);\n\n if (!resolvedDefinition) {\n throw new Error(\"Attempted to resolve `\".concat(name, \"` via ensureSafeComponent, but nothing was found.\"));\n }\n\n return curry(0, name, owner, {\n named: {},\n positional: []\n });\n }\n\n function contextForLookup(owner) {\n if ((0, _runtime.macroCondition)(true)) {\n return owner;\n } else {\n return {\n owner: owner\n };\n }\n }\n});","function _typeof(obj) { \"@babel/helpers - typeof\"; if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\ndefine(\"@embroider/util/index\", [\"exports\", \"@embroider/util/ember-private-api\"], function (_exports, _emberPrivateApi) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.ensureSafeComponent = ensureSafeComponent;\n _exports.EnsureSafeComponentHelper = void 0;\n\n function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\n\n function _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\n function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\n function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\n function _iterableToArrayLimit(arr, i) { if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"] != null) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; }\n\n function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\n\n function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\n function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }\n\n function _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function\"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }\n\n function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }\n\n function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }\n\n function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) { return call; } return _assertThisInitialized(self); }\n\n function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return self; }\n\n function _isNativeReflectConstruct() { if (typeof Reflect === \"undefined\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \"function\") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }\n\n function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }\n\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\n var EnsureSafeComponentHelper = /*#__PURE__*/function (_Ember$Helper) {\n _inherits(EnsureSafeComponentHelper, _Ember$Helper);\n\n var _super = _createSuper(EnsureSafeComponentHelper);\n\n function EnsureSafeComponentHelper() {\n _classCallCheck(this, EnsureSafeComponentHelper);\n\n return _super.apply(this, arguments);\n }\n\n _createClass(EnsureSafeComponentHelper, [{\n key: \"compute\",\n value: function compute(_ref) {\n var _ref2 = _slicedToArray(_ref, 1),\n value = _ref2[0];\n\n return ensureSafeComponent(value, this);\n }\n }]);\n\n return EnsureSafeComponentHelper;\n }(Ember.Helper);\n\n _exports.EnsureSafeComponentHelper = EnsureSafeComponentHelper;\n\n function handleString(name, thingWithOwner) {\n (true && !(false) && Ember.deprecate(\"You're trying to invoke the component \\\"\".concat(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/master/ADDON-AUTHOR-GUIDE.md#when-youre-passing-a-component-to-someone-else',\n until: 'embroider',\n for: '@embroider/util',\n since: '0.27.0'\n }));\n var owner = Ember.getOwner(thingWithOwner);\n return (0, _emberPrivateApi.lookupCurriedComponentDefinition)(name, owner);\n }\n\n function ensureRegistered(klass, owner) {\n var service = owner.lookup('service:-ensure-registered');\n (true && !(service) && Ember.assert('Could not lookup private -ensure-registered service', service));\n return service.register(klass, owner);\n }\n\n function handleClass(klass, thingWithOwner) {\n var owner = Ember.getOwner(thingWithOwner);\n var nonce = ensureRegistered(klass, owner);\n return (0, _emberPrivateApi.lookupCurriedComponentDefinition)(nonce, owner);\n }\n});","function _typeof(obj) { \"@babel/helpers - typeof\"; if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\ndefine(\"@embroider/util/services/ensure-registered\", [\"exports\"], function (_exports) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.default = void 0;\n\n function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\n function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }\n\n function _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function\"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }\n\n function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }\n\n function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }\n\n function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) { return call; } return _assertThisInitialized(self); }\n\n function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return self; }\n\n function _isNativeReflectConstruct() { if (typeof Reflect === \"undefined\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \"function\") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }\n\n function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }\n\n function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\n var EnsureRegisteredService = /*#__PURE__*/function (_Ember$Service) {\n _inherits(EnsureRegisteredService, _Ember$Service);\n\n var _super = _createSuper(EnsureRegisteredService);\n\n function EnsureRegisteredService() {\n var _this;\n\n _classCallCheck(this, EnsureRegisteredService);\n\n for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n args[_key] = arguments[_key];\n }\n\n _this = _super.call.apply(_super, [this].concat(args));\n\n _defineProperty(_assertThisInitialized(_this), \"classNonces\", new WeakMap());\n\n _defineProperty(_assertThisInitialized(_this), \"nonceCounter\", 0);\n\n return _this;\n }\n\n _createClass(EnsureRegisteredService, [{\n key: \"register\",\n value: function register(klass) {\n var owner = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Ember.getOwner(this);\n var nonce = this.classNonces.get(klass);\n\n if (nonce == null) {\n nonce = \"-ensure\".concat(this.nonceCounter++);\n this.classNonces.set(klass, nonce);\n owner.register(\"component:\".concat(nonce), klass);\n }\n\n return nonce;\n }\n }]);\n\n return EnsureRegisteredService;\n }(Ember.Service);\n\n _exports.default = EnsureRegisteredService;\n});","define(\"@fortawesome/ember-fontawesome/components/fa-icon\", [\"exports\", \"@fortawesome/ember-fontawesome/templates/components/fa-icon\", \"@fortawesome/fontawesome-svg-core\", \"ember-get-config\"], function (_exports, _faIcon, _fontawesomeSvgCore, _emberGetConfig) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.default = void 0;\n\n function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }\n\n function _nonIterableSpread() { throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\n function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\n function _iterableToArray(iter) { if (typeof Symbol !== \"undefined\" && Symbol.iterator in Object(iter)) return Array.from(iter); }\n\n function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }\n\n function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\n function _typeof(obj) { \"@babel/helpers - typeof\"; if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\n function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\n function getWithDefault(object, key, defaultValue) {\n var value = Ember.get(object, key);\n\n if (value === undefined) {\n return defaultValue;\n }\n\n return value;\n }\n\n function getConfigOption(key, defaultValue) {\n return getWithDefault(_emberGetConfig.default, \"fontawesome.\".concat(key), defaultValue);\n }\n\n function objectWithKey(key, value) {\n return Array.isArray(value) && value.length > 0 || !Array.isArray(value) && value ? _defineProperty({}, key, value) : {};\n }\n\n function classList() {\n var _classes;\n\n var classes = (_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 }, _defineProperty(_classes, \"fa-\".concat(this.size), getWithDefault(this, 'size', null) !== null), _defineProperty(_classes, \"fa-rotate-\".concat(this.rotation), getWithDefault(this, 'rotation', null) !== null), _defineProperty(_classes, \"fa-pull-\".concat(this.pull), getWithDefault(this, 'pull', null) !== null), _classes);\n return Object.keys(classes).map(function (key) {\n return classes[key] ? key : null;\n }).filter(function (key) {\n return key;\n });\n }\n\n function normalizeIconArgs(prefix, icon) {\n var defaultPrefix = getConfigOption('defaultPrefix', 'fas');\n\n if (!icon) {\n return {\n prefix: defaultPrefix,\n iconName: null\n };\n }\n\n if (_typeof(icon) === 'object' && icon.prefix && icon.iconName) {\n return icon;\n }\n\n if (typeof prefix === 'string' && typeof icon === 'string') {\n return {\n prefix: prefix,\n iconName: icon\n };\n }\n\n if (typeof icon === 'string') {\n return {\n prefix: defaultPrefix,\n iconName: icon\n };\n }\n }\n\n var IconComponent = Ember.Component.extend({\n init: function init() {\n this._super.apply(this, arguments);\n\n if (this.params && this.params.length) {\n (true && !(false) && Ember.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: [// attributes watched for mutation\n 'data-prefix', 'data-icon', 'data-fa-transform', 'data-fa-mask', 'data-fa-processed', // accessibility attributes\n 'aria-hidden', 'aria-labelledby', 'focusable', // svg attributes\n 'role', 'xmlns', 'viewBox', 'safeStyle:style'],\n html: Ember.computed('abstractIcon.children.[]', function () {\n var abstractIcon = this.abstractIcon;\n var newHtml;\n\n if (!abstractIcon) {\n newHtml = Ember.String.htmlSafe('');\n } else {\n newHtml = Ember.String.htmlSafe(abstractIcon.children.reduce(function (acc, cur) {\n return \"\".concat(acc).concat((0, _fontawesomeSvgCore.toHtml)(cur));\n }, ''));\n }\n\n return newHtml;\n }),\n safeStyle: Ember.computed('attributes', function () {\n var attributes = this.attributes;\n var style = getWithDefault(attributes, 'style');\n return style ? Ember.String.htmlSafe(\"\".concat(style)) : undefined;\n }),\n iconOrPositionalParam: Ember.computed('icon', 'params.[]', function () {\n if (this.icon) {\n return this.icon;\n }\n\n if (this.params && this.params.length) {\n return this.params[0];\n }\n\n return null;\n }),\n abstractIcon: Ember.computed('border', 'fixedWidth', 'flip', 'icon', 'iconOrPositionalParam', 'listItem', 'mask', 'prefix', 'pull', 'pulse', 'rotation', 'size', 'spin', 'symbol', 'title', 'transform', function () {\n var iconLookup = normalizeIconArgs(this.prefix, this.iconOrPositionalParam);\n var classes = objectWithKey('classes', _toConsumableArray(classList.bind(this)()));\n var transformProp = this.transform;\n var transform = objectWithKey('transform', typeof transformProp === 'string' ? _fontawesomeSvgCore.parse.transform(transformProp) : transformProp);\n var mask = objectWithKey('mask', normalizeIconArgs(null, this.mask));\n var symbol = getWithDefault(this, 'symbol', false);\n var title = getWithDefault(this, 'title', null);\n\n if (title) {\n title = \"\".concat(title);\n }\n\n var o = Ember.assign({}, classes, transform, mask, {\n symbol: symbol,\n title: title\n });\n var renderedIcon = (0, _fontawesomeSvgCore.icon)(iconLookup, o);\n\n if (!renderedIcon) {\n console.warn(\"Could not find icon: iconName=\".concat(iconLookup.iconName, \", prefix=\").concat(iconLookup.prefix));\n return null;\n }\n\n return renderedIcon.abstract[0];\n }),\n attributes: Ember.computed('abstractIcon.attributes', function () {\n var abstractIcon = this.abstractIcon;\n return abstractIcon ? abstractIcon.attributes : {};\n }),\n allClasses: Ember.computed('abstractIcon', 'attributes.class', 'class', function () {\n var abstractIcon = this.abstractIcon;\n\n if (!abstractIcon) {\n return _fontawesomeSvgCore.config.replacementClass;\n }\n\n var attributes = this.attributes;\n var iconClasses = getWithDefault(attributes, 'class');\n return iconClasses;\n }),\n 'data-prefix': Ember.computed('attributes.data-prefix', function () {\n return getWithDefault(this.attributes, 'data-prefix');\n }),\n 'data-icon': Ember.computed('attributes.data-icon', function () {\n return getWithDefault(this.attributes, 'data-icon');\n }),\n 'data-fa-transform': Ember.computed('attributes.data-fa-transform', function () {\n return getWithDefault(this.attributes, 'data-fa-transform');\n }),\n 'data-fa-mask': Ember.computed('attributes.data-fa-mask', function () {\n return getWithDefault(this.attributes, 'data-fa-mask');\n }),\n 'data-fa-processed': Ember.computed('attributes.data-fa-processed', function () {\n return getWithDefault(this.attributes, 'data-fa-processed');\n }),\n 'aria-hidden': Ember.computed('attributes.aria-hidden', function () {\n return getWithDefault(this.attributes, 'aria-hidden');\n }),\n 'aria-labelledby': Ember.computed('attributes.aria-labelledby', function () {\n return getWithDefault(this.attributes, 'aria-labelledby');\n }),\n 'focusable': Ember.computed('attributes.focusable', function () {\n return getWithDefault(this.attributes, 'focusable');\n }),\n 'role': Ember.computed('attributes.role', function () {\n return getWithDefault(this.attributes, 'role');\n }),\n 'xmlns': Ember.computed('attributes.xmlns', function () {\n return getWithDefault(this.attributes, 'xmlns');\n }),\n 'viewBox': Ember.computed('abstractIcon', 'attributes.viewBox', function () {\n var abstractIcon = this.abstractIcon;\n\n if (!abstractIcon) {\n return '0 0 448 512';\n }\n\n return getWithDefault(this.attributes, 'viewBox');\n })\n }); // Enables {{fa-icon 'iconnamehere'}} syntax, while still allowing {{fa-icon icon='iconnamehere'}}\n\n IconComponent.reopenClass({\n positionalParams: 'params'\n });\n var _default = IconComponent;\n _exports.default = _default;\n});","define(\"@fortawesome/ember-fontawesome/templates/components/fa-icon\", [\"exports\"], function (_exports) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.default = void 0;\n\n var _default = Ember.HTMLBars.template({\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\n _exports.default = _default;\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\n function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\n function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }\n\n function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\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 /*#__PURE__*/function () {\n function _class2(owner) {\n _classCallCheck(this, _class2);\n\n _defineProperty(this, \"capabilities\", capabilities);\n\n setOwner(this, owner);\n }\n\n _createClass(_class2, [{\n key: \"createComponent\",\n value: function createComponent(ComponentClass, args) {\n if (true\n /* DEBUG */\n ) {\n _component.ARGS_SET.set(args.named, true);\n }\n\n return new ComponentClass(getOwner(this), args.named);\n }\n }, {\n key: \"getContext\",\n value: function getContext(component) {\n return component;\n }\n }], [{\n key: \"create\",\n value: function create(attrs) {\n var owner = getOwner(attrs);\n return new this(owner);\n }\n }]);\n\n return _class2;\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\n function _typeof(obj) { \"@babel/helpers - typeof\"; if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\n function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\n function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }\n\n function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\n var ARGS_SET;\n _exports.ARGS_SET = ARGS_SET;\n\n if (true\n /* DEBUG */\n ) {\n _exports.ARGS_SET = ARGS_SET = new WeakMap();\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\n\n var BaseComponent = /*#__PURE__*/function () {\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 function BaseComponent(owner, args) {\n _classCallCheck(this, BaseComponent);\n\n _defineProperty(this, \"args\", void 0);\n\n if (true\n /* DEBUG */\n && !(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: \".concat(this.constructor.name, \". You can pass them directly, or use ...arguments to pass all arguments through.\"));\n }\n\n this.args = args;\n (0, _owner.setOwner)(this, owner);\n }\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 *