@warp-drive/legacy 5.9.0-alpha.2 → 5.9.0-alpha.21

package/dist/unpkg/dev-deprecated/adapter/json-api.js

@@ -117,7 +117,7 @@ import { RESTAdapter } from './rest.js';
   namespace property on the adapter:
 
   ```js [app/adapters/application.js]
-  import JSONAPIAdapter from '@warp-drive/legacy/adapter/json-api';
+  import { JSONAPIAdapter } from '@warp-drive/legacy/adapter/json-api';
 
   export default class ApplicationAdapter extends JSONAPIAdapter {
     namespace = 'api/1';
@@ -146,6 +146,10 @@ import { RESTAdapter } from './rest.js';
   @constructor
 */
 class JSONAPIAdapter extends RESTAdapter {
+  /**
+   * The `Content-Type` header used when serializing request bodies
+   * that don't otherwise specify one.
+   */
   _defaultContentType = 'application/vnd.api+json';
 
   /**
@@ -227,6 +231,14 @@ class JSONAPIAdapter extends RESTAdapter {
       }
     });
   }
+
+  /**
+   * Determines the pathname for a given type.
+   *
+   * Unlike the base `BuildURLMixin` implementation, dasherizes (rather
+   * than camelizes) the type name before pluralizing it, per the
+   * {json:api} convention for member names.
+   */
   pathForType(modelName) {
     const dasherized = dasherize(modelName);
     return pluralize(dasherized);

package/dist/unpkg/dev-deprecated/adapter/rest.js

@@ -234,13 +234,39 @@ const AdapterWithBuildURLMixin = Adapter.extend(BuildURLMixin);
   @public
 */
 class RESTAdapter extends AdapterWithBuildURLMixin {
+  /**
+   * @private
+   */
+
+  /**
+   * @private
+   */
+
+  /**
+   * See "Host customization" above.
+   */
+
+  /**
+   * See "Namespace customization" above.
+   */
+
   /**
     This property allows ajax to still be used instead when `false`.
      @default true
     @public
   */
   useFetch = true;
+
+  /**
+   * The `Content-Type` header used when serializing request bodies
+   * that don't otherwise specify one.
+   */
   _defaultContentType = 'application/json; charset=utf-8';
+
+  /**
+   * The FastBoot service instance, if running in a FastBoot environment.
+   * Lazily looked up on first access.
+   */
   get fastboot() {
     // Avoid computed property override deprecation in fastboot as suggested by:
     // https://deprecations.emberjs.com/v3.x/#toc_computed-property-override
@@ -250,6 +276,10 @@ class RESTAdapter extends AdapterWithBuildURLMixin {
     }
     return this._fastboot = getOwner(this).lookup('service:fastboot');
   }
+
+  /**
+   * Sets the FastBoot service instance to use.
+   */
   static {
     decorateMethodV2(this.prototype, "fastboot", [computed()]);
   }
@@ -646,7 +676,13 @@ class RESTAdapter extends AdapterWithBuildURLMixin {
     return expandedURL.join('/');
   }
 
-  // http://stackoverflow.com/questions/417142/what-is-the-maximum-length-of-a-url-in-different-browsers
+  /**
+   * The maximum URL length to allow when coalescing `findRecord` requests
+   * into a single `findMany` request via {@link RESTAdapter.groupRecordsForFindMany | groupRecordsForFindMany}.
+   * Requests that would exceed this length are split into multiple groups.
+   *
+   * See http://stackoverflow.com/questions/417142/what-is-the-maximum-length-of-a-url-in-different-browsers
+   */
   maxURLLength = 2048;
 
   /**
@@ -707,8 +743,8 @@ class RESTAdapter extends AdapterWithBuildURLMixin {
     if (this.isSuccess(status, headers, payload)) {
       return payload;
     } else if (this.isInvalid(status, headers, payload)) {
-      // @ts-expect-error needs cast to ApiError
-      return new InvalidError(typeof payload === 'object' && 'errors' in payload ? payload.errors : undefined);
+      const errorPayload = payload ?? {};
+      return new InvalidError(typeof errorPayload === 'object' && 'errors' in errorPayload ? errorPayload.errors : undefined);
     }
     const errors = this.normalizeErrorResponse(status, headers, payload);
     const detailedMessage = this.generatedDetailedMessage(status, headers, payload, requestData);

package/dist/unpkg/dev-deprecated/adapter.js

@@ -4,6 +4,8 @@ import { a as decorateFieldV2, i as initializeDeferredDecorator } from "./runtim
 import Mixin from '@ember/object/mixin';
 import { camelize, pluralize } from '@warp-drive/utilities/string';
 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+
 /*
  The structure of this file is such because typing Mixins is hard. Here we've structured it in
  such a way as to maximize the type information that a consumer can utilize. There are simpler
@@ -14,37 +16,18 @@ import { camelize, pluralize } from '@warp-drive/utilities/string';
 // `interface BuildURLMixin { buildURL: typeof buildURL }`
 // then an extending class overwriting one of the methods will break because typescript
 // thinks it is a switch from an instance prop (that is a method) to an instance method.
+/**
+ * The methods provided by the `BuildURLMixin` mixin (see the exported
+ * `BuildURLMixin` {@link Mixin} below).
+ *
+ * See also {@link MixtBuildURLMixin}, the interface used to type `this`
+ * within these methods.
+ */
 
 // prevents the final constructed object from needing to add
 // host and namespace which are provided by the final consuming
 // class to the prototype which can result in overwrite errors
 
-/**
-  ## Using BuildURLMixin
-
-  To use URL building, include the mixin when extending an adapter, and call `buildURL` where needed.
-  The default behaviour is designed for RESTAdapter.
-
-  ### Example
-
-  ```javascript
-  import Adapter, { BuildURLMixin } from '@ember-data/adapter';
-
-  export default class ApplicationAdapter extends Adapter.extend(BuildURLMixin) {
-    findRecord(store, type, id, snapshot) {
-      var url = this.buildURL(type.modelName, id, snapshot, 'findRecord');
-      return this.ajax(url, 'GET');
-    }
-  }
-  ```
-
-  ### Attributes
-
-  The `host` and `namespace` attributes will be used if defined, and are optional.
-
-  @class BuildURLMixin
-  @public
-*/
 /**
     Builds a URL for a given type and optional ID.
 
@@ -490,6 +473,13 @@ const mixinProps = {
   urlPrefix,
   pathForType
 };
+
+/**
+ * The `Mixin` implementation of {@link BuildURLMixin}, ready to be applied
+ * to an `EmberObject` subclass such as an `Adapter`.
+ *
+ * @public
+ */
 const BuildURLMixin = Mixin.create(mixinProps);
 
 /**
@@ -739,6 +729,13 @@ class Adapter extends EmberObject {
     decorateFieldV2(this.prototype, "store", [service]);
   }
   #store = (initializeDeferredDecorator(this, "store"), void 0);
+  /**
+   * The Store service instance that owns this Adapter.
+   */
+  /**
+   * @private
+   */
+
   /**
     The `findRecord()` method is invoked when the store is asked for a record that
     has not previously been loaded. In response to `findRecord()` being called, you

package/dist/unpkg/dev-deprecated/compat/builders.js

@@ -15,7 +15,6 @@ import { storeFor, recordIdentifierFor } from '@warp-drive/core';
   @deprecated
   @public
   @param type the name of the resource
-  @param query a query to be used by the adapter
   @param options optional, may include `adapterOptions` hash which will be passed to adapter.findAll
   @return request config
 */

package/dist/unpkg/dev-deprecated/compat/extensions.js

@@ -1,18 +1,74 @@
-import { get, set } from '@ember/object';
+import { get, set, setProperties, notifyPropertyChange, getProperties } from '@ember/object';
+import { removeObserver, addObserver } from '@ember/object/observers';
 import { compare } from '@ember/utils';
-import Ember from 'ember';
 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);
+    switch (method) {
+      case 'addObserver':
+        return addObserver(this, ...args);
+      case 'cacheFor':
+        throw new Error('cacheFor has been removed and will not be replaced');
+      case 'decrementProperty':
+        {
+          const keyName = args[0];
+          const decrement = args[1] ?? 1;
+          (test => {
+            if (!test) {
+              throw new Error('Must pass a numeric value to decrementProperty');
+            }
+          })((typeof decrement === 'number' || !isNaN(parseFloat(decrement))) && isFinite(decrement));
+          return set(this, keyName, (get(this, keyName) || 0) - decrement);
+        }
+      case 'get':
+        return get(this, ...args);
+      case 'getProperties':
+        return getProperties(this, ...args);
+      case 'incrementProperty':
+        {
+          const keyName = args[0];
+          const increment = args[1] ?? 1;
+          (test => {
+            if (!test) {
+              throw new Error('Must pass a numeric value to incrementProperty');
+            }
+          })(!isNaN(parseFloat(String(increment))) && isFinite(increment));
+          return set(this, keyName, (parseFloat(get(this, keyName)) || 0) + increment);
+        }
+      case 'notifyPropertyChange':
+        return notifyPropertyChange(this, ...args);
+      case 'removeObserver':
+        return removeObserver(this, ...args);
+      case 'set':
+        return set(this, ...args);
+      case 'setProperties':
+        return setProperties(this, ...args);
+      case 'toggleProperty':
+        {
+          const key = args[0];
+          return set(this, key, !get(this, key));
+        }
+    }
   };
 });
+/**
+ * A schema extension that adds the classic `EmberObject` API (`get`, `set`,
+ * `getProperties`, `setProperties`, `incrementProperty`, `decrementProperty`,
+ * `toggleProperty`, `notifyPropertyChange`, `addObserver`, `removeObserver`)
+ * to reactive array resources.
+ */
 const EmberObjectArrayExtension = {
   kind: 'array',
   name: 'ember-object',
   features: EmberObjectFeatures
 };
+/**
+ * A schema extension that adds the classic `EmberObject` API (`get`, `set`,
+ * `getProperties`, `setProperties`, `incrementProperty`, `decrementProperty`,
+ * `toggleProperty`, `notifyPropertyChange`, `addObserver`, `removeObserver`)
+ * to reactive object resources.
+ */
 const EmberObjectExtension = {
   kind: 'object',
   name: 'ember-object',
@@ -234,9 +290,30 @@ const EmberArrayLikeFeatures = {
     return this.at(-1);
   }
 };
+
+/**
+ * A schema extension that adds Ember's classic `MutableArray`/`Enumerable`
+ * style methods (`pushObject`, `removeObject`, `mapBy`, `filterBy`,
+ * `sortBy`, `firstObject`, `lastObject`, etc.) to reactive array resources.
+ */
 const EmberArrayLikeExtension = {
   kind: 'array',
   name: 'ember-array-like',
   features: EmberArrayLikeFeatures
 };
+
+/**
+ * Extracts the element type of an array type, or `never` if `T` is not an array.
+ */
+
+/**
+ * Adds the classic `EmberObject` API (as registered by {@link EmberObjectExtension}/
+ * {@link EmberObjectArrayExtension}) to the type of a reactive resource.
+ */
+
+/**
+ * Adds Ember's classic array-like API (as registered by {@link EmberArrayLikeExtension})
+ * to the type of a reactive array resource.
+ */
+
 export { EmberArrayLikeExtension, EmberObjectArrayExtension, EmberObjectExtension };

package/dist/unpkg/dev-deprecated/compat/utils.js

@@ -145,6 +145,20 @@ function formattedId(id) {
   }
   return id === null ? null : String(id);
 }
+
+/**
+ * Like {@link formattedId}, but asserts that `id` is not `null` rather
+ * than allowing and passing through `null`.
+ *
+ * @public
+ */
+
+/**
+ * Throws, since `id` is `null`.
+ *
+ * @public
+ */
+
 function expectId(id) {
   AssertFn('expectId: id must not be null', id !== null);
   return formattedId(id);

package/dist/unpkg/dev-deprecated/compat.js

@@ -303,7 +303,23 @@ function config(packageRoot) {
 function getGlobalConfig() {
   return runtimeConfig.global;
 }
-const runtimeConfig = initializeRuntimeMacrosConfig();
+
+// Welcome intrepid developer!
+//
+// While this data is "global", this is a private variable.
+//
+// do not build features based off of its contents,
+// or assume it will have the same name in future releases.
+const runtimeConfig = globalThis.__embroider_macros__runtime_config__ ||= {};
+runtimeConfig.packages ||= {};
+runtimeConfig.global ||= {};
+
+// In the off chance there are duplicate copies of @embroider/macros in the dep graph
+// (due to the package manager messing up)
+// Let's try to merge them together via the above global well known variable
+const localConfig = initializeRuntimeMacrosConfig();
+Object.assign(runtimeConfig.packages, localConfig.packages);
+Object.assign(runtimeConfig.global, localConfig.global);
 
 // this exists to be targeted by our babel plugin
 function initializeRuntimeMacrosConfig() {
@@ -417,6 +433,14 @@ if (updaters) {
   }
 }
 const PotentialLegacyOperations = new Set(['findRecord', 'findAll', 'query', 'queryRecord', 'findBelongsTo', 'findHasMany', 'updateRecord', 'createRecord', 'deleteRecord']);
+
+/**
+ * A {@link Handler} that fulfills legacy `findRecord`/`findAll`/`query`/
+ * `queryRecord`/`findBelongsTo`/`findHasMany`/`createRecord`/`updateRecord`/
+ * `deleteRecord` requests using the store's configured {@link MinimumAdapterInterface | adapter}
+ * and {@link MinimumSerializerInterface | serializer}, passing any other
+ * request through to the next handler unchanged.
+ */
 const LegacyNetworkHandler = {
   request(context, next) {
     // if we are not a legacy request, move on
@@ -1121,6 +1145,10 @@ function pushPayload(modelName, inputPayload) {
   serializer.pushPayload(this, payload);
 }
 
+/**
+ * Serializes a record using the store's legacy network layer, as with
+ * {@link LegacyStoreCompat.serializeRecord | store.serializeRecord}.
+ */
 // TODO @runspired @deprecate records should implement their own serialization if desired
 function serializeRecord(record, options) {
   // TODO we used to check if the record was destroyed here
@@ -1129,6 +1157,11 @@ function serializeRecord(record, options) {
   }
   return this._fetchManager.createSnapshot(recordIdentifierFor(record)).serialize(options);
 }
+
+/**
+ * Destroys any adapters/serializers the legacy network layer has created
+ * for this store, invoked when the store itself is destroyed.
+ */
 function cleanup() {
   // enqueue destruction of any adapters/serializers we have created
   for (const adapterName in this._adapterCache) {

package/dist/unpkg/dev-deprecated/{errors-Spt6ubMd.js → errors-Bzidntpi.js}

@@ -76,7 +76,7 @@ PromiseBelongsTo.prototype[LegacyPromiseProxy] = true;
 
 /**
   This class is returned as the result of accessing an async hasMany relationship
-  on an instance of a Model extending from `@ember-data/model`.
+  on an instance of a Model extending from `@warp-drive/legacy/model`.
 
   A PromiseManyArray is an iterable proxy that allows templates to consume related
   ManyArrays and update once their contents are no longer pending.
@@ -90,6 +90,20 @@ PromiseBelongsTo.prototype[LegacyPromiseProxy] = true;
   @public
 */
 class PromiseManyArray {
+  /**
+   * The promise for the relationship's content, or `null` once
+   * {@link PromiseManyArray.destroy | destroy} has been called.
+   */
+
+  /**
+   * Whether {@link PromiseManyArray.destroy | destroy} has been called.
+   */
+
+  /**
+   * The resolved `ManyArray` for the relationship, if the promise has
+   * resolved, else `null`.
+   */
+
   constructor(promise, content) {
     this._update(promise, content);
     this.isDestroyed = false;
@@ -110,6 +124,9 @@ class PromiseManyArray {
     return this.content ? this.content.length : 0;
   }
 
+  /**
+   * @private
+   */
   // this will error if someone tries to call
   // A(identifierArray) since it is not configurable
   // which is preferrable to the `meta` override we used
@@ -211,6 +228,12 @@ class PromiseManyArray {
 
   //---- Methods on EmberObject that we should keep
 
+  /**
+   * Tears down this proxy, releasing its {@link PromiseManyArray.content | content} and
+   * {@link PromiseManyArray.promise | promise} and marking it as {@link PromiseManyArray.isDestroyed | destroyed}.
+   *
+   * @public
+   */
   destroy() {
     this.isDestroyed = true;
     this.content = null;

package/dist/unpkg/dev-deprecated/{hooks-DOXegvhL.js → hooks-DVXhMW14.js}

@@ -1,7 +1,15 @@
 import { setOwner, getOwner } from '@ember/application';
 import { assertPrivateStore, setRecordIdentifier, StoreMap } from '@warp-drive/core/store/-private';
-import { g as getModelFactory } from "./schema-provider-BP6_8N-V.js";
+import { g as getModelFactory } from "./schema-provider-ZwO5_fZw.js";
 import { n as normalizeModelName } from "./util-CWr5WQOT.js";
+
+/**
+ * The `instantiateRecord` hook implementation for use with `Model`. Pass
+ * this to your store's `instantiateRecord` method when configuring the
+ * store to use `Model` for schema/record instantiation.
+ *
+ * @public
+ */
 function instantiateRecord(identifier, createRecordArgs) {
   const type = identifier.type;
 
@@ -26,14 +34,37 @@ function instantiateRecord(identifier, createRecordArgs) {
   })(factory);
   return factory.class.create(createOptions);
 }
+
+/**
+ * The `teardownRecord` hook implementation for use with `Model`. Pass this
+ * to your store's `teardownRecord` method when configuring the store to
+ * use `Model` for schema/record instantiation.
+ *
+ * @public
+ */
 function teardownRecord(record) {
   (test => {
     if (!test) {
-      throw new Error(`expected to receive an instance of Model from @ember-data/model. If using a custom model make sure you implement teardownRecord`);
+      throw new Error(`expected to receive an instance of Model from @warp-drive/legacy/model. If using a custom model make sure you implement teardownRecord`);
     }
   })('destroy' in record);
   record.destroy();
 }
+
+/**
+ * The `modelFor` implementation for use with `Model`, exposed on the store
+ * as `store.modelFor(type)` when the store is configured to use `Model`.
+ * Returns the `Model` subclass registered for the given type, if any.
+ *
+ * @public
+ */
+
+/**
+ * Overload accepting a raw type string instead of a typed record instance.
+ *
+ * @public
+ */
+
 function modelFor(modelName) {
   assertPrivateStore(this);
   (test => {