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

package/dist/adapter.js

@@ -735,7 +735,6 @@ const service = s.service ?? s.inject;
   For an example of the implementation, see `RESTAdapter`, the
   included REST adapter.
 
-  @class Adapter
   @public
 */
 class Adapter extends EmberObject {
@@ -766,12 +765,7 @@ class Adapter extends EmberObject {
       }
     }
     ```
-     @param {Store} store
-    @param {Model} type
-    @param {String} id
-    @param {Snapshot} snapshot
-    @return {Promise} promise
-    @public
+     @public
   */
   // @ts-expect-error
   findRecord(store, type, id, snapshot) {
@@ -799,11 +793,7 @@ class Adapter extends EmberObject {
       }
     }
     ```
-     @param {Store} store
-    @param {Model} type
-    @param {null} neverSet a value is never provided to this argument
-    @param {SnapshotRecordArray} snapshotRecordArray
-    @return {Promise} promise
+     @param neverSet a value is never provided to this argument
     @public
   */
   findAll(store, type, neverSet, snapshotRecordArray) {
@@ -831,13 +821,7 @@ class Adapter extends EmberObject {
       }
     }
     ```
-     @param {Store} store
-    @param {Model} type
-    @param {Object} query
-    @param {Collection} recordArray
-    @param {Object} adapterOptions
-    @return {Promise} promise
-    @public
+     @public
   */
   // @ts-expect-error
   query(store, type, query) {
@@ -863,14 +847,8 @@ class Adapter extends EmberObject {
       }
     }
     ```
-     @param {Store} store
-    @param {subclass of Model} type
-    @param {Object} query
-    @param {Object} adapterOptions
-    @return {Promise} promise
-    @public
+     @public
   */
-  // @ts-expect-error
   queryRecord(store, type, query, adapterOptions) {
     if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
       throw new Error('You subclassed the Adapter class but missing a queryRecord override');
@@ -918,10 +896,7 @@ class Adapter extends EmberObject {
       }
     }
     ```
-     @param {Snapshot} snapshot
-    @param {Object}   options
-    @return {Object} serialized snapshot
-    @public
+     @public
   */
   serialize(snapshot, options) {
     const serialized = snapshot.serialize(options);
@@ -961,11 +936,7 @@ class Adapter extends EmberObject {
       }
     }
     ```
-     @param {Store} store
-    @param {Model} type   the Model class of the record
-    @param {Snapshot} snapshot
-    @return {Promise} promise
-    @public
+     @public
   */
   // @ts-expect-error
   createRecord(store, type, snapshot) {

package/dist/compat/-private.js

@@ -1 +1 @@
-export { F as FetchManager, S as SaveOp, c as Snapshot, b as SnapshotRecordArray, u as upgradeStore } from "../-private-DFfBszo5.js";
+export { F as FetchManager, S as SaveOp, c as Snapshot, b as SnapshotRecordArray, u as upgradeStore } from "../-private-CKrP0ogQ.js";

package/dist/compat/extensions.js

@@ -0,0 +1,243 @@
+import { get, set } from '@ember/object';
+import { compare } from '@ember/utils';
+import Ember from 'ember';
+import { macroCondition, getGlobalConfig } from '@embroider/macros';
+const EmberObjectFeatures = {};
+const EmberObjectMethods = ['addObserver', 'cacheFor', 'decrementProperty', 'get', 'getProperties', 'incrementProperty', 'notifyPropertyChange', 'removeObserver', 'set', 'setProperties', 'toggleProperty'];
+EmberObjectMethods.forEach(method => {
+  EmberObjectFeatures[method] = function delegatedMethod(...args) {
+    return Ember[method](this, ...args);
+  };
+});
+const EmberObjectArrayExtension = {
+  kind: 'array',
+  name: 'ember-object',
+  features: EmberObjectFeatures
+};
+const EmberObjectExtension = {
+  kind: 'object',
+  name: 'ember-object',
+  features: EmberObjectFeatures
+};
+const EmberArrayLikeFeatures = {
+  addObject(obj) {
+    const index = this.indexOf(obj);
+    if (index === -1) {
+      this.push(obj);
+    }
+    return this;
+  },
+  addObjects(objs) {
+    objs.forEach(obj => {
+      const index = this.indexOf(obj);
+      if (index === -1) {
+        this.push(obj);
+      }
+    });
+    return this;
+  },
+  popObject() {
+    return this.pop();
+  },
+  pushObject(obj) {
+    this.push(obj);
+    return obj;
+  },
+  pushObjects(objs) {
+    this.push(...objs);
+    return this;
+  },
+  shiftObject() {
+    return this.shift();
+  },
+  unshiftObject(obj) {
+    this.unshift(obj);
+    return obj;
+  },
+  unshiftObjects(objs) {
+    this.unshift(...objs);
+    return this;
+  },
+  objectAt(index) {
+    //For negative index values go back from the end of the array
+    const arrIndex = Math.sign(index) === -1 ? this.length + index : index;
+    return this[arrIndex];
+  },
+  objectsAt(indices) {
+    // @ts-expect-error adding MutableArray method
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-call
+    return indices.map(index => this.objectAt(index));
+  },
+  removeAt(index) {
+    this.splice(index, 1);
+    return this;
+  },
+  insertAt(index, obj) {
+    this.splice(index, 0, obj);
+    return this;
+  },
+  removeObject(obj) {
+    const index = this.indexOf(obj);
+    if (index !== -1) {
+      this.splice(index, 1);
+    }
+    return this;
+  },
+  removeObjects(objs) {
+    objs.forEach(obj => {
+      const index = this.indexOf(obj);
+      if (index !== -1) {
+        this.splice(index, 1);
+      }
+    });
+    return this;
+  },
+  toArray() {
+    return this.slice();
+  },
+  replace(idx, amt, objects) {
+    if (objects) {
+      this.splice(idx, amt, ...objects);
+    } else {
+      this.splice(idx, amt);
+    }
+  },
+  clear() {
+    this.splice(0, this.length);
+    return this;
+  },
+  setObjects(objects) {
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`setObjects expects to receive an array as its argument`);
+      }
+    })(Array.isArray(objects)) : {};
+    this.splice(0, this.length);
+    this.push(...objects);
+    return this;
+  },
+  reverseObjects() {
+    this.reverse();
+    return this;
+  },
+  compact() {
+    return this.filter(v => v !== null && v !== undefined);
+  },
+  any(callback, target) {
+    return this.some(callback, target);
+  },
+  isAny(prop, value) {
+    const hasValue = arguments.length === 2;
+    return this.some(v => hasValue ? v[prop] === value : v[prop] === true);
+  },
+  isEvery(prop, value) {
+    const hasValue = arguments.length === 2;
+    return this.every(v => hasValue ? v[prop] === value : v[prop] === true);
+  },
+  getEach(key) {
+    return this.map(value => get(value, key));
+  },
+  mapBy(key) {
+    return this.map(value => get(value, key));
+  },
+  findBy(key, value) {
+    if (arguments.length === 2) {
+      return this.find(val => {
+        return get(val, key) === value;
+      });
+    } else {
+      return this.find(val => Boolean(get(val, key)));
+    }
+  },
+  filterBy(key, value) {
+    if (arguments.length === 2) {
+      return this.filter(record => {
+        return get(record, key) === value;
+      });
+    }
+    return this.filter(record => {
+      return Boolean(get(record, key));
+    });
+  },
+  sortBy(...sortKeys) {
+    return this.slice().sort((a, b) => {
+      for (let i = 0; i < sortKeys.length; i++) {
+        const key = sortKeys[i];
+        const propA = get(a, key);
+        const propB = get(b, key);
+        // return 1 or -1 else continue to the next sortKey
+        const compareValue = compare(propA, propB);
+        if (compareValue) {
+          return compareValue;
+        }
+      }
+      return 0;
+    });
+  },
+  invoke(key, ...args) {
+    return this.map(value => value[key](...args));
+  },
+  addArrayObserver() {},
+  removeArrayObserver() {},
+  arrayContentWillChange() {},
+  arrayContentDidChange() {},
+  reject(callback, target) {
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error('`reject` expects a function as first argument.');
+      }
+    })(typeof callback === 'function') : {};
+    return this.filter((...args) => {
+      return !callback.apply(target, args);
+    });
+  },
+  rejectBy(key, value) {
+    if (arguments.length === 2) {
+      return this.filter(record => {
+        return get(record, key) !== value;
+      });
+    }
+    return this.filter(record => {
+      return !get(record, key);
+    });
+  },
+  setEach(key, value) {
+    this.forEach(item => set(item, key, value));
+  },
+  uniq() {
+    return Array.from(new Set(this));
+  },
+  uniqBy(key) {
+    const seen = new Set();
+    const result = [];
+    this.forEach(item => {
+      const value = get(item, key);
+      if (seen.has(value)) {
+        return;
+      }
+      seen.add(value);
+      result.push(item);
+    });
+    return result;
+  },
+  without(value) {
+    const newArr = this.slice();
+    const index = this.indexOf(value);
+    if (index !== -1) {
+      newArr.splice(index, 1);
+    }
+    return newArr;
+  },
+  get firstObject() {
+    return this.at(0);
+  },
+  get lastObject() {
+    return this.at(-1);
+  }
+};
+const EmberArrayLikeExtension = {
+  kind: 'array',
+  name: 'ember-array-like',
+  features: EmberArrayLikeFeatures
+};
+export { EmberArrayLikeExtension, EmberObjectArrayExtension, EmberObjectExtension };

package/dist/compat.js

@@ -1,7 +1,7 @@
 import { getOwner } from '@ember/application';
 import { recordIdentifierFor } from '@warp-drive/core';
 import { waitFor, _deprecatingNormalize } from '@warp-drive/core/store/-private';
-import { p as payloadIsNotBlank, n as normalizeResponseHelper, i as iterateData, F as FetchManager, S as SaveOp, a as assertIdentifierHasId, b as SnapshotRecordArray } from "./-private-DFfBszo5.js";
+import { p as payloadIsNotBlank, n as normalizeResponseHelper, i as iterateData, F as FetchManager, S as SaveOp, a as assertIdentifierHasId, b as SnapshotRecordArray } from "./-private-CKrP0ogQ.js";
 import { macroCondition, getGlobalConfig } from '@embroider/macros';
 function _findHasMany(adapter, store, identifier, link, relationship, options) {
   const promise = Promise.resolve().then(() => {
@@ -868,9 +868,8 @@ function serializerFor(modelName) {
     ```
 
     @public
-    @param {String} modelName The name of the model type for this payload
-    @param {Object} payload
-    @return {Object} The normalized payload
+    @param modelName The name of the model type for this payload
+    @return The normalized payload
   */
 // TODO @runspired @deprecate users should call normalize on the associated serializer directly
 function normalize(modelName, payload) {

package/dist/{errors-D74uk36r.js → errors-BX5wowuz.js}

@@ -1,7 +1,7 @@
 import { memoized, defineSignal, defineNonEnumerableSignal, isStableIdentifier, recordIdentifierFor, storeFor, peekCache, SOURCE, fastPush, RelatedCollection, notifyInternalSignal, ARRAY_SIGNAL } from '@warp-drive/core/store/-private';
 import { getOrSetGlobal } from '@warp-drive/core/types/-private';
 import { EnableHydration } from '@warp-drive/core/types/request';
-import { u as upgradeStore } from "./-private-DFfBszo5.js";
+import { u as upgradeStore } from "./-private-CKrP0ogQ.js";
 import { computed, get } from '@ember/object';
 import PromiseProxyMixin from '@ember/object/promise-proxy-mixin';
 import ObjectProxy from '@ember/object/proxy';
@@ -17,6 +17,8 @@ const LegacyPromiseProxy = Symbol.for('LegacyPromiseProxy');
 
 const Extended = PromiseObject;
 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+
 /**
   A PromiseBelongsTo is a PromiseObject that also proxies certain method calls
   to the underlying belongsTo model.
@@ -68,8 +70,8 @@ class PromiseBelongsTo extends Extended {
     await legacySupport.reloadBelongsTo(key, options);
     return this;
   }
-  [LegacyPromiseProxy] = true;
 }
+PromiseBelongsTo.prototype[LegacyPromiseProxy] = true;
 
 /**
   This class is returned as the result of accessing an async hasMany relationship
@@ -91,6 +93,7 @@ class PromiseManyArray {
   constructor(promise, content) {
     this._update(promise, content);
     this.isDestroyed = false;
+    this[LegacyPromiseProxy] = true;
   }
 
   /**
@@ -195,12 +198,9 @@ class PromiseManyArray {
    * chain this promise
    *
    * @public
-   * @param success
-   * @param fail
-   * @return {Promise}
    */
-  then(s, f) {
-    return this.promise.then(s, f);
+  then(success, rejected) {
+    return this.promise.then(success, rejected);
   }
 
   /**
@@ -256,6 +256,8 @@ class PromiseManyArray {
   }
 
   //---- Our own stuff
+
+  /** @internal */
   static {
     decorateMethodV2(this.prototype, "meta", [memoized]);
   }
@@ -271,7 +273,6 @@ class PromiseManyArray {
   }) {
     return new this(promise, content);
   }
-  [LegacyPromiseProxy] = true;
 }
 defineSignal(PromiseManyArray.prototype, 'content', null);
 defineSignal(PromiseManyArray.prototype, 'isPending', false);
@@ -760,9 +761,9 @@ class HasManyReference {
       return false;
     }
     const relationship = this.graph.getData(this.hasManyRelationship.identifier, this.key);
-    return relationship.data?.every(identifier => {
+    return relationship.data ? relationship.data.every(identifier => {
       return this.store._instanceCache.recordIsLoaded(identifier, true) === true;
-    });
+    }) : false;
   }
 
   /**
@@ -1668,6 +1669,7 @@ class LegacySupport {
           type: definition.type,
           identifier: this.identifier,
           cache: this.cache,
+          field: this.store.schema.fields(this.identifier).get(key),
           identifiers,
           key,
           meta: doc.meta || null,