@warp-drive/legacy 5.9.0-beta.0 → 5.9.0-beta.2

package/dist/adapter/error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.js","names":["getOrSetGlobal","macroCondition","getGlobalConfig","_AdapterError","errors","message","isAdapterError","error","Error","call","stack","description","fileName","lineNumber","name","number","title","detail","prototype","Object","create","code","extend","extendFn","AdapterError","ErrorClass","defaultMessage","ParentErrorClass","WarpDrive","env","DEBUG","test","Array","isArray","InvalidError","TimeoutError","AbortError","UnauthorizedError","ForbiddenError","NotFoundError","ConflictError","ServerError"],"sources":["../../src/adapter/error.ts"],"sourcesContent":["/* oxlint-disable typescript/no-unsafe-assignment */\n/* oxlint-disable typescript/no-unsafe-member-access */\n// oxlint-disable-next-line no-unused-vars\nimport type { RequestManager } from '@warp-drive/core';\nimport { assert } from '@warp-drive/core/build-config/macros';\n// oxlint-disable-next-line no-unused-vars\nimport type { Handler } from '@warp-drive/core/request';\nimport { getOrSetGlobal } from '@warp-drive/core/types/-private';\nimport type { ApiError } from '@warp-drive/core/types/spec/error';\n\nfunction _AdapterError(this: AdapterRequestError, errors: ApiError[], message = 'Adapter operation failed') {\n  this.isAdapterError = true;\n  const error = Error.call(this, message);\n\n  if (error) {\n    this.stack = error.stack;\n    // @ts-expect-error untyped\n    this.description = error.description;\n    // @ts-expect-error untyped\n    this.fileName = error.fileName;\n    // @ts-expect-error untyped\n    this.lineNumber = error.lineNumber;\n    this.message = error.message;\n    this.name = error.name;\n    // @ts-expect-error untyped\n    this.number = error.number;\n  }\n\n  this.errors = errors || [\n    {\n      title: 'Adapter Error',\n      detail: message,\n    },\n  ];\n}\n\n/**\n * The shape of the errors thrown/returned by {@link AdapterError} and its subclasses.\n */\nexport interface AdapterRequestError<T extends string = string> extends Error {\n  /**\n   * A property signifying that an Error uses the {@link AdapterRequestError} interface.\n   */\n  isAdapterError: true;\n  /**\n   * A short code identifying the kind of error, e.g. `'NotFoundError'`.\n   */\n  code: T;\n  /**\n   * The {json:api} formatted errors associated with the request.\n   */\n  errors: ApiError[];\n}\n/**\n * The static interface shared by {@link AdapterError} and its subclasses,\n * allowing further subclassing via {@link AdapterRequestErrorConstructor.extend | extend}.\n */\nexport interface AdapterRequestErrorConstructor<Instance extends AdapterRequestError = AdapterRequestError> {\n  new (errors?: unknown[], message?: string): Instance;\n  /**\n   * Creates a new {@link AdapterRequestErrorConstructor} that inherits from this one.\n   */\n  extend(options: { message: string }): AdapterRequestErrorConstructor;\n}\n\n_AdapterError.prototype = Object.create(Error.prototype);\n\n_AdapterError.prototype.code = 'AdapterError';\n_AdapterError.extend = extendFn(_AdapterError as unknown as AdapterRequestErrorConstructor);\n\n/**\n * The {@link AdapterRequestError} shape thrown by the {@link AdapterError} constructor.\n */\nexport type AdapterError = AdapterRequestError<'AdapterError'>;\n/**\n * :::danger\n * ⚠️ **This is LEGACY documentation** for a feature that is no longer encouraged to be used.\n * If starting a new app or thinking of implementing a new adapter, consider writing a\n * {@link Handler} instead to be used with the {@link RequestManager}\n * :::\n *\n * An `AdapterError` is used by an adapter to signal that an error occurred\n * during a request to an external API. It indicates a generic error, and\n * subclasses are used to indicate specific error states.\n *\n * To create a custom error to signal a specific error state in communicating\n * with an external API, extend the `AdapterError`. For example, if the\n * external API exclusively used HTTP `503 Service Unavailable` to indicate\n * it was closed for maintenance:\n *\n * ```js [app/adapters/maintenance-error.js]\n * import AdapterError from '@warp-drive/legacy/adapter/error';\n *\n * export default AdapterError.extend({ message: \"Down for maintenance.\" });\n * ```\n *\n * This error would then be returned by an adapter's `handleResponse` method:\n *\n * ```js [app/adapters/application.js]\n * import JSONAPIAdapter from '@warp-drive/legacy/adapter/json-api';\n * import MaintenanceError from './maintenance-error';\n *\n * export default class ApplicationAdapter extends JSONAPIAdapter {\n *   handleResponse(status) {\n *     if (503 === status) {\n *       return new MaintenanceError();\n *     }\n *\n *     return super.handleResponse(...arguments);\n *   }\n * }\n * ```\n *\n * And can then be detected in an application and used to send the user to an\n * `under-maintenance` route:\n *\n * ```js [app/routes/application.js]\n * import MaintenanceError from '../adapters/maintenance-error';\n *\n * export default class ApplicationRoute extends Route {\n *   actions: {\n *     error(error, transition) {\n *       if (error instanceof MaintenanceError) {\n *         this.transitionTo('under-maintenance');\n *         return;\n *       }\n *\n *       // ...other error handling logic\n *     }\n *   }\n * }\n * ```\n *\n * ### Signaling an Error Without Extending `AdapterError`\n *\n * Extending `AdapterError` (or one of its subclasses) is a convenience, not\n * a requirement. WarpDrive only inspects an error for the {@link AdapterRequestError}\n * shape: an `isAdapterError` flag, a `code`, and an {json:api}-formatted\n * `errors` array. Any object satisfying that shape — including a plain\n * `Error` with those properties attached — will be handled identically to\n * an instance created via `new AdapterError()` or one of its subclasses.\n *\n * This is useful when you'd rather not introduce a class hierarchy, or\n * when the error needs to be constructed from data you don't control\n * (for example, re-throwing an error surfaced by a third-party library):\n *\n * ```js [app/adapters/application.js]\n * import JSONAPIAdapter from '@warp-drive/legacy/adapter/json-api';\n *\n * export default class ApplicationAdapter extends JSONAPIAdapter {\n *   handleResponse(status, headers, payload) {\n *     if (status === 503) {\n *       const error = new Error('Down for maintenance.');\n *       error.isAdapterError = true;\n *       error.code = 'MaintenanceError';\n *       error.errors = [{ title: 'Service Unavailable', detail: 'Down for maintenance.' }];\n *       return error;\n *     }\n *\n *     return super.handleResponse(status, headers, payload);\n *   }\n * }\n * ```\n *\n * Because `code` is just a string you control, `error instanceof AdapterError`\n * checks won't match a plain object built this way — consumers should\n * instead branch on `error.isAdapterError && error.code === 'MaintenanceError'`,\n * or on whichever of the {@link AdapterError} subclasses' `code` values\n * (e.g. `'InvalidError'`, `'NotFoundError'`) the error's `code` matches.\n *\n * @public\n */\nexport const AdapterError: AdapterRequestErrorConstructor<AdapterError> = getOrSetGlobal(\n  'AdapterError',\n  _AdapterError as unknown as AdapterRequestErrorConstructor<AdapterError>\n);\ntype ErrorExtender = (opts: { message?: string }) => AdapterRequestErrorConstructor;\nfunction extendFn(ErrorClass: AdapterRequestErrorConstructor): ErrorExtender {\n  return function ({ message: defaultMessage }: { message?: string } = {}) {\n    return extend(ErrorClass, defaultMessage);\n  };\n}\n\nfunction extend<Final extends AdapterRequestError>(\n  ParentErrorClass: AdapterRequestErrorConstructor,\n  defaultMessage?: string\n): AdapterRequestErrorConstructor<Final> {\n  const ErrorClass = function (this: AdapterRequestError, errors: ApiError[], message?: string) {\n    assert('`AdapterError` expects json-api formatted errors array.', Array.isArray(errors || []));\n    ParentErrorClass.call(this, errors, message || defaultMessage);\n  };\n  // oxlint-disable-next-line typescript/no-unsafe-argument\n  ErrorClass.prototype = Object.create(ParentErrorClass.prototype);\n  ErrorClass.extend = extendFn(ErrorClass as unknown as AdapterRequestErrorConstructor);\n\n  return ErrorClass as unknown as AdapterRequestErrorConstructor<Final>;\n}\n\n/**\n * The {@link AdapterRequestError} shape thrown by the {@link InvalidError} constructor.\n */\n// TODO @deprecate extractError documentation\nexport type InvalidError = AdapterRequestError<'InvalidError'>;\n/**\n * An `InvalidError` is used by an adapter to signal that the external API\n * was unable to process a request because the content was not semantically\n * correct or meaningful per the API. Usually, this means a record failed\n * some form of server-side validation. When a promise from an adapter is\n * rejected with an `InvalidError` the record will transition to the\n * `invalid` state and the errors will be set to the `errors` property on\n * the record.\n *\n * For WarpDrive to correctly map errors to their corresponding properties\n * on the model, WarpDrive expects each error to be a valid {json:api} error\n * object with a `source.pointer` that matches the property name. For\n * example, if you had a `Post` model that looked like this:\n *\n * ```js [app/models/post.js]\n * import { Model, attr } from '@warp-drive/legacy/model';\n *\n * export default class PostModel extends Model {\n *   @attr('string') title;\n *   @attr('string') content;\n * }\n * ```\n *\n * To show an error from the server related to the `title` and `content`\n * properties your adapter could return a promise that rejects with an\n * `InvalidError` that looks like this:\n *\n * ```js [app/adapters/post.js]\n * import RSVP from 'RSVP';\n * import RESTAdapter from '@warp-drive/legacy/adapter/rest';\n * import { InvalidError } from '@warp-drive/legacy/adapter/error';\n *\n * export default class ApplicationAdapter extends RESTAdapter {\n *   updateRecord() {\n *     // Fictional adapter that always rejects\n *     return RSVP.reject(new InvalidError([\n *       {\n *         detail: 'Must be unique',\n *         source: { pointer: '/data/attributes/title' }\n *       },\n *       {\n *         detail: 'Must not be blank',\n *         source: { pointer: '/data/attributes/content' }\n *       }\n *     ]));\n *   }\n * }\n * ```\n *\n * Your backend may use different property names for your records; the\n * store will attempt to extract and normalize the errors using the\n * serializer's `extractErrors` method before the errors get added to the\n * model. As a result, it is safe for the `InvalidError` to wrap the error\n * payload unaltered.\n *\n * @public\n */\nexport const InvalidError: AdapterRequestErrorConstructor<InvalidError> = getOrSetGlobal(\n  'InvalidError',\n  extend<InvalidError>(AdapterError, 'The adapter rejected the commit because it was invalid')\n);\nInvalidError.prototype.code = 'InvalidError';\n\n/**\n * The {@link AdapterRequestError} shape thrown by the {@link TimeoutError} constructor.\n */\nexport type TimeoutError = AdapterRequestError<'TimeoutError'>;\n/**\n * A `TimeoutError` is used by an adapter to signal that a request to the\n * external API has timed out, i.e. no response was received from the\n * external API within an allowed time period.\n *\n * An example use case would be to warn the user to check their internet\n * connection if an adapter operation has timed out:\n *\n * ```js [app/routes/application.js]\n * import { TimeoutError } from '@warp-drive/legacy/adapter/error';\n *\n * export default class ApplicationRoute extends Route {\n *   @action\n *   error(error, transition) {\n *     if (error instanceof TimeoutError) {\n *       // alert the user\n *       alert('Are you still connected to the Internet?');\n *       return;\n *     }\n *\n *     // ...other error handling logic\n *   }\n * }\n * ```\n *\n * @public\n */\nexport const TimeoutError: AdapterRequestErrorConstructor<TimeoutError> = getOrSetGlobal(\n  'TimeoutError',\n  extend(AdapterError, 'The adapter operation timed out')\n);\nTimeoutError.prototype.code = 'TimeoutError';\n\n/**\n * The {@link AdapterRequestError} shape thrown by the {@link AbortError} constructor.\n */\nexport type AbortError = AdapterRequestError<'AbortError'>;\n/**\n * An `AbortError` is used by an adapter to signal that a request to the\n * external API was aborted. For example, this can occur if the user\n * navigates away from the current page after a request to the external API\n * has been initiated but before a response has been received.\n *\n * Because an aborted request is typically expected (the user chose to\n * navigate away, or a newer request superseded this one) rather than\n * exceptional, an example use case would be to silently ignore it instead\n * of surfacing an error to the user:\n *\n * ```js [app/routes/application.js]\n * import { AbortError } from '@warp-drive/legacy/adapter/error';\n *\n * export default class ApplicationRoute extends Route {\n *   @action\n *   error(error, transition) {\n *     if (error instanceof AbortError) {\n *       // the request was aborted, nothing to report\n *       return;\n *     }\n *\n *     // ...other error handling logic\n *   }\n * }\n * ```\n *\n * @public\n */\nexport const AbortError: AdapterRequestErrorConstructor<AbortError> = getOrSetGlobal(\n  'AbortError',\n  extend(AdapterError, 'The adapter operation was aborted')\n);\nAbortError.prototype.code = 'AbortError';\n\n/**\n * The {@link AdapterRequestError} shape thrown by the {@link UnauthorizedError} constructor.\n */\nexport type UnauthorizedError = AdapterRequestError<'UnauthorizedError'>;\n/**\n * A `UnauthorizedError` equates to an HTTP `401 Unauthorized` response\n * status. It is used by an adapter to signal that a request to the external\n * API was rejected because authorization is required and has failed or has\n * not yet been provided.\n *\n * An example use case would be to redirect the user to a login route if a\n * request is unauthorized:\n *\n * ```js [app/routes/application.js]\n * import { UnauthorizedError } from '@warp-drive/legacy/adapter/error';\n *\n * export default class ApplicationRoute extends Route {\n *   @action\n *   error(error, transition) {\n *     if (error instanceof UnauthorizedError) {\n *       // go to the login route\n *       this.transitionTo('login');\n *       return;\n *     }\n *\n *     // ...other error handling logic\n *   }\n * }\n * ```\n *\n * @public\n */\nexport const UnauthorizedError: AdapterRequestErrorConstructor<UnauthorizedError> = getOrSetGlobal(\n  'UnauthorizedError',\n  extend(AdapterError, 'The adapter operation is unauthorized')\n);\nUnauthorizedError.prototype.code = 'UnauthorizedError';\n\n/**\n * The {@link AdapterRequestError} shape thrown by the {@link ForbiddenError} constructor.\n */\nexport type ForbiddenError = AdapterRequestError<'ForbiddenError'>;\n/**\n * A `ForbiddenError` equates to an HTTP `403 Forbidden` response status.\n * It is used by an adapter to signal that a request to the external API was\n * valid but the server is refusing to respond to it. If authorization was\n * provided and is valid, then the authenticated user does not have the\n * necessary permissions for the request.\n *\n * Unlike an {@link UnauthorizedError}, retrying the request with different\n * credentials will not help; the currently authenticated user simply lacks\n * permission. An example use case would be to show the user a \"you don't\n * have access to this\" message rather than redirecting them to log in:\n *\n * ```js [app/routes/application.js]\n * import { ForbiddenError } from '@warp-drive/legacy/adapter/error';\n *\n * export default class ApplicationRoute extends Route {\n *   @action\n *   error(error, transition) {\n *     if (error instanceof ForbiddenError) {\n *       this.transitionTo('forbidden');\n *       return;\n *     }\n *\n *     // ...other error handling logic\n *   }\n * }\n * ```\n *\n * @public\n */\nexport const ForbiddenError: AdapterRequestErrorConstructor<ForbiddenError> = getOrSetGlobal(\n  'ForbiddenError',\n  extend(AdapterError, 'The adapter operation is forbidden')\n);\nForbiddenError.prototype.code = 'ForbiddenError';\n\n/**\n * The {@link AdapterRequestError} shape thrown by the {@link NotFoundError} constructor.\n */\nexport type NotFoundError = AdapterRequestError<'NotFoundError'>;\n/**\n * A `NotFoundError` equates to an HTTP `404 Not Found` response status.\n * It is used by an adapter to signal that a request to the external API\n * was rejected because the resource could not be found on the API.\n *\n * An example use case would be to detect if the user has entered a route\n * for a specific model that does not exist. For example:\n *\n * ```js [app/routes/post.js]\n * import { NotFoundError } from '@warp-drive/legacy/adapter/error';\n *\n * export default class PostRoute extends Route {\n *   @service store;\n *   model(params) {\n *     return this.store.findRecord('post', params.post_id);\n *   }\n *   @action\n *   error(error, transition) {\n *     if (error instanceof NotFoundError) {\n *       // redirect to a list of all posts instead\n *       this.transitionTo('posts');\n *     } else {\n *       // otherwise let the error bubble\n *       return true;\n *     }\n *   }\n * }\n * ```\n *\n * @public\n */\nexport const NotFoundError: AdapterRequestErrorConstructor<NotFoundError> = getOrSetGlobal(\n  'NotFoundError',\n  extend(AdapterError, 'The adapter could not find the resource')\n);\nNotFoundError.prototype.code = 'NotFoundError';\n\n/**\n * The {@link AdapterRequestError} shape thrown by the {@link ConflictError} constructor.\n */\nexport type ConflictError = AdapterRequestError<'ConflictError'>;\n/**\n * A `ConflictError` equates to an HTTP `409 Conflict` response status.\n * It is used by an adapter to indicate that the request could not be\n * processed because of a conflict in the request. An example scenario\n * would be when creating a record with a client-generated ID but that ID\n * is already known to the external API.\n *\n * An example use case would be to surface a conflict-specific message so\n * the user can retry with different input:\n *\n * ```js [app/routes/application.js]\n * import { ConflictError } from '@warp-drive/legacy/adapter/error';\n *\n * export default class ApplicationRoute extends Route {\n *   @action\n *   error(error, transition) {\n *     if (error instanceof ConflictError) {\n *       alert('That identifier is already in use, please choose another.');\n *       return;\n *     }\n *\n *     // ...other error handling logic\n *   }\n * }\n * ```\n *\n * @public\n */\nexport const ConflictError: AdapterRequestErrorConstructor<ConflictError> = getOrSetGlobal(\n  'ConflictError',\n  extend(AdapterError, 'The adapter operation failed due to a conflict')\n);\nConflictError.prototype.code = 'ConflictError';\n\n/**\n * The {@link AdapterRequestError} shape thrown by the {@link ServerError} constructor.\n */\nexport type ServerError = AdapterRequestError<'ServerError'>;\n/**\n * A `ServerError` equates to an HTTP `500 Internal Server Error` response\n * status. It is used by the adapter to indicate that a request has failed\n * because of an error in the external API, and is unlikely to succeed if\n * retried immediately.\n *\n * An example use case would be to show a generic \"something went wrong on\n * our end\" message rather than one implying the user made a mistake:\n *\n * ```js [app/routes/application.js]\n * import { ServerError } from '@warp-drive/legacy/adapter/error';\n *\n * export default class ApplicationRoute extends Route {\n *   @action\n *   error(error, transition) {\n *     if (error instanceof ServerError) {\n *       alert('Something went wrong on our end. Please try again later.');\n *       return;\n *     }\n *\n *     // ...other error handling logic\n *   }\n * }\n * ```\n *\n * @public\n */\nexport const ServerError: AdapterRequestErrorConstructor<ServerError> = getOrSetGlobal(\n  'ServerError',\n  extend(AdapterError, 'The adapter operation failed due to a server error')\n);\nServerError.prototype.code = 'ServerError';\n"],"mappings":"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"}

package/{declarations → dist}/adapter/json-api.d.ts

@@ -1,10 +1,9 @@
-import type { Store } from "@warp-drive/core";
-import type { ModelSchema } from "@warp-drive/core/types";
-import type { HTTPMethod } from "@warp-drive/core/types/request";
-import type { AdapterPayload } from "../compat.js";
-import type { Snapshot, SnapshotRecordArray } from "../compat/-private.js";
-import type { FetchRequestInit, JQueryRequestInit, QueryState } from "./rest.js";
-import { RESTAdapter } from "./rest.js";
+import { _ as AdapterPayload, m as Snapshot, p as SnapshotRecordArray } from "../compat-BbNNmTM-.js";
+import { i as RESTAdapter, n as JQueryRequestInit, r as QueryState, t as FetchRequestInit } from "../rest-0NhtexIq.js";
+import { Store } from "@warp-drive/core";
+import { HTTPMethod } from "@warp-drive/core/types/request";
+import { ModelSchema } from "@warp-drive/core/types";
+//#region src/adapter/json-api.d.ts
 /**
 ## Overview
 
@@ -118,7 +117,7 @@ Endpoint paths can be prefixed with a `namespace` by setting the
 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';
@@ -147,16 +146,20 @@ Requests for the `person` model would now target
 @constructor
 */
 declare class JSONAPIAdapter extends RESTAdapter {
-	_defaultContentType: string;
-	/**
+  /**
+   * The `Content-Type` header used when serializing request bodies
+   * that don't otherwise specify one.
+   */
+  _defaultContentType: string;
+  /**
 	@private
 	@param {String} url
 	@param {String} type The request type GET, POST, PUT, DELETE etc.
 	@param {Object} options
 	@return {Object}
 	*/
-	ajaxOptions(url: string, type: HTTPMethod, options?: JQueryAjaxSettings | RequestInit): JQueryRequestInit | FetchRequestInit;
-	/**
+  ajaxOptions(url: string, type: HTTPMethod, options?: JQueryAjaxSettings | RequestInit): JQueryRequestInit | FetchRequestInit;
+  /**
 	By default the JSONAPIAdapter will send each find request coming from a `store.find`
 	or from accessing a relationship separately to the server. If your server supports passing
 	ids as a query string, you can set coalesceFindRequests to true to coalesce all find requests
@@ -212,12 +215,19 @@ declare class JSONAPIAdapter extends RESTAdapter {
 	@public
 	@type {Boolean}
 	*/
-	get coalesceFindRequests(): boolean;
-	set coalesceFindRequests(value: boolean);
-	findMany(store: Store, type: ModelSchema, ids: string[], snapshots: Snapshot[]): Promise<AdapterPayload>;
-	pathForType(modelName: string): string;
-	updateRecord(store: Store, schema: ModelSchema, snapshot: Snapshot): Promise<AdapterPayload>;
-	/**
+  get coalesceFindRequests(): boolean;
+  set coalesceFindRequests(value: boolean);
+  findMany(store: Store, type: ModelSchema, ids: string[], snapshots: Snapshot[]): Promise<AdapterPayload>;
+  /**
+   * 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: string): string;
+  updateRecord(store: Store, schema: ModelSchema, snapshot: Snapshot): Promise<AdapterPayload>;
+  /**
 	Used by `findAll` and `findRecord` to build the query's `data` hash
 	supplied to the ajax method.
 	
@@ -226,6 +236,8 @@ declare class JSONAPIAdapter extends RESTAdapter {
 	@param  {Snapshot} snapshot
 	@return {Object}
 	*/
-	buildQuery(snapshot: Snapshot | SnapshotRecordArray): QueryState;
+  buildQuery(snapshot: Snapshot | SnapshotRecordArray): QueryState;
 }
+//#endregion
 export { JSONAPIAdapter };
+//# sourceMappingURL=json-api.d.ts.map

package/dist/adapter/json-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-api.d.ts","names":[],"sources":["../../src/adapter/json-api.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA2JM,uBAAuB;;;;;EAK3B;;;;;;;;EASA,YACE,aACA,MAAM,YACN,UAAS,qBAAqB,cAC7B,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAgEnB;MAQA,qBAAqB;EAIzB,SAAS,OAAO,OAAO,MAAM,aAAa,eAAe,WAAW,aAAa,QAAQ;;;;;;;;EAYzF,YAAY;EAKZ,aAAa,OAAO,OAAO,QAAQ,aAAa,UAAU,WAAW,QAAQ;;;;;;;;;;EAoB7E,WAAW,UAAU,WAAW,sBAAsB"}

package/dist/adapter/json-api.js

@@ -1,132 +1,266 @@
-import { dasherize, pluralize } from '@warp-drive/utilities/string';
-import '@ember/debug';
-import { macroCondition, getGlobalConfig } from '@embroider/macros';
-import { b as serializeIntoHash } from "../serialize-into-hash-DPZYoF-i.js";
-import { RESTAdapter } from './rest.js';
-
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-
-class JSONAPIAdapter extends RESTAdapter {
-  _defaultContentType = 'application/vnd.api+json';
-
-  /**
-    @private
-    @param {String} url
-    @param {String} type The request type GET, POST, PUT, DELETE etc.
-    @param {Object} options
-    @return {Object}
-  */
-  ajaxOptions(url, type, options = {}) {
-    const hash = super.ajaxOptions(url, type, options);
-    const headers = hash.headers = hash.headers || {};
-    headers['Accept'] = headers['Accept'] || 'application/vnd.api+json';
-    return hash;
-  }
-
-  /**
-    By default the JSONAPIAdapter will send each find request coming from a `store.find`
-    or from accessing a relationship separately to the server. If your server supports passing
-    ids as a query string, you can set coalesceFindRequests to true to coalesce all find requests
-    within a single runloop.
-     For example, if you have an initial payload of:
-     ```javascript
-    {
-      data: {
-        id: 1,
-        type: 'post',
-        relationship: {
-          comments: {
-            data: [
-              { id: 1, type: 'comment' },
-              { id: 2, type: 'comment' }
-            ]
-          }
-        }
-      }
-    }
-    ```
-     By default calling `post.comments` will trigger the following requests(assuming the
-    comments haven't been loaded before):
-     ```
-    GET /comments/1
-    GET /comments/2
-    ```
-     If you set coalesceFindRequests to `true` it will instead trigger the following request:
-     ```
-    GET /comments?filter[id]=1,2
-    ```
-     Setting coalesceFindRequests to `true` also works for `store.find` requests and `belongsTo`
-    relationships accessed within the same runloop. If you set `coalesceFindRequests: true`
-     ```javascript
-    store.findRecord('comment', 1);
-    store.findRecord('comment', 2);
-    ```
-     will also send a request to: `GET /comments?filter[id]=1,2`
-     Note: Requests coalescing rely on URL building strategy. So if you override `buildURL` in your app
-    `groupRecordsForFindMany` more likely should be overridden as well in order for coalescing to work.
-     @property coalesceFindRequests
-    @public
-    @type {Boolean}
-  */
-  get coalesceFindRequests() {
-    const coalesceFindRequests = this._coalesceFindRequests;
-    if (typeof coalesceFindRequests === 'boolean') {
-      return coalesceFindRequests;
-    }
-    return this._coalesceFindRequests = false;
-  }
-  set coalesceFindRequests(value) {
-    this._coalesceFindRequests = value;
-  }
-  findMany(store, type, ids, snapshots) {
-    const url = this.buildURL(type.modelName, ids, snapshots, 'findMany');
-    return this.ajax(url, 'GET', {
-      data: {
-        filter: {
-          id: ids.join(',')
-        }
-      }
-    });
-  }
-  pathForType(modelName) {
-    const dasherized = dasherize(modelName);
-    return pluralize(dasherized);
-  }
-  updateRecord(store, schema, snapshot) {
-    const data = serializeIntoHash(store, schema, snapshot);
-    const type = snapshot.modelName;
-    const id = snapshot.id;
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-      if (!test) {
-        throw new Error(`Attempted to update the ${type} record, but the record has no id`);
-      }
-    })(typeof id === 'string' && id.length > 0) : {};
-    const url = this.buildURL(type, id, snapshot, 'updateRecord');
-    return this.ajax(url, 'PATCH', {
-      data: data
-    });
-  }
-
-  /**
-    Used by `findAll` and `findRecord` to build the query's `data` hash
-    supplied to the ajax method.
-     @since 2.5.0
-    @public
-    @param  {Snapshot} snapshot
-    @return {Object}
-  */
-  buildQuery(snapshot) {
-    const query = {};
-    if (snapshot) {
-      const {
-        include
-      } = snapshot;
-      const normalizedInclude = Array.isArray(include) ? include.join(',') : include;
-      if (normalizedInclude) {
-        query.include = normalizedInclude;
-      }
-    }
-    return query;
-  }
+import { t as serializeIntoHash } from "../-private-DQ6Iap2t.js";
+import { RESTAdapter } from "./rest.js";
+import { getGlobalConfig, macroCondition } from "@embroider/macros";
+import { dasherize, pluralize } from "@warp-drive/utilities/string";
+
+//#region src/adapter/json-api.ts
+/**
+## Overview
+
+:::danger
+⚠️ **This is LEGACY documentation** for a feature that is no longer encouraged to be used.
+If starting a new app or thinking of implementing a new adapter, consider writing a
+{@link Handler} instead to be used with the {@link RequestManager}
+:::
+
+The `JSONAPIAdapter` is an adapter whichtransforms the store's
+requests into HTTP requests that follow the [JSON API format](http://jsonapi.org/format/).
+
+## JSON API Conventions
+
+The JSONAPIAdapter uses JSON API conventions for building the URL
+for a record and selecting the HTTP verb to use with a request. The
+actions you can take on a record map onto the following URLs in the
+JSON API adapter:
+
+<table>
+<tr>
+<th>
+Action
+</th>
+<th>
+HTTP Verb
+</th>
+<th>
+URL
+</th>
+</tr>
+<tr>
+<th>
+`store.findRecord('post', 123)`
+</th>
+<td>
+GET
+</td>
+<td>
+/posts/123
+</td>
+</tr>
+<tr>
+<th>
+`store.findAll('post')`
+</th>
+<td>
+GET
+</td>
+<td>
+/posts
+</td>
+</tr>
+<tr>
+<th>
+Update `postRecord.save()`
+</th>
+<td>
+PATCH
+</td>
+<td>
+/posts/123
+</td>
+</tr>
+<tr>
+<th>
+Create `store.createRecord('post').save()`
+</th>
+<td>
+POST
+</td>
+<td>
+/posts
+</td>
+</tr>
+<tr>
+<th>
+Delete `postRecord.destroyRecord()`
+</th>
+<td>
+DELETE
+</td>
+<td>
+/posts/123
+</td>
+</tr>
+</table>
+
+## Success and failure
+
+The JSONAPIAdapter will consider a success any response with a
+status code of the 2xx family ("Success"), as well as 304 ("Not
+Modified"). Any other status code will be considered a failure.
+
+On success, the request promise will be resolved with the full
+response payload.
+
+Failed responses with status code 422 ("Unprocessable Entity") will
+be considered "invalid". The response will be discarded, except for
+the `errors` key. The request promise will be rejected with a
+`InvalidError`. This error object will encapsulate the saved
+`errors` value.
+
+Any other status codes will be treated as an adapter error. The
+request promise will be rejected, similarly to the invalid case,
+but with an instance of `AdapterError` instead.
+
+### Endpoint path customization
+
+Endpoint paths can be prefixed with a `namespace` by setting the
+namespace property on the adapter:
+
+```js [app/adapters/application.js]
+import { JSONAPIAdapter } from '@warp-drive/legacy/adapter/json-api';
+
+export default class ApplicationAdapter extends JSONAPIAdapter {
+namespace = 'api/1';
 }
-export { JSONAPIAdapter };
+```
+Requests for the `person` model would now target `/api/1/people/1`.
+
+### Host customization
+
+An adapter can target other hosts by setting the `host` property.
+
+```js [app/adapters/application.js]
+import JSONAPIAdapter from '@warp-drive/legacy/adapter/json-api';
+
+export default class ApplicationAdapter extends JSONAPIAdapter {
+host = 'https://api.example.com';
+}
+```
+
+Requests for the `person` model would now target
+`https://api.example.com/people/1`.
+
+@since 1.13.0
+@class JSONAPIAdapter
+@public
+@constructor
+*/
+var JSONAPIAdapter = class extends RESTAdapter {
+	/**
+	* The `Content-Type` header used when serializing request bodies
+	* that don't otherwise specify one.
+	*/
+	_defaultContentType = "application/vnd.api+json";
+	/**
+	@private
+	@param {String} url
+	@param {String} type The request type GET, POST, PUT, DELETE etc.
+	@param {Object} options
+	@return {Object}
+	*/
+	ajaxOptions(url, type, options = {}) {
+		const hash = super.ajaxOptions(url, type, options);
+		const headers = hash.headers = hash.headers || {};
+		headers["Accept"] = headers["Accept"] || "application/vnd.api+json";
+		return hash;
+	}
+	/**
+	By default the JSONAPIAdapter will send each find request coming from a `store.find`
+	or from accessing a relationship separately to the server. If your server supports passing
+	ids as a query string, you can set coalesceFindRequests to true to coalesce all find requests
+	within a single runloop.
+	For example, if you have an initial payload of:
+	```javascript
+	{
+	data: {
+	id: 1,
+	type: 'post',
+	relationship: {
+	comments: {
+	data: [
+	{ id: 1, type: 'comment' },
+	{ id: 2, type: 'comment' }
+	]
+	}
+	}
+	}
+	}
+	```
+	By default calling `post.comments` will trigger the following requests(assuming the
+	comments haven't been loaded before):
+	```
+	GET /comments/1
+	GET /comments/2
+	```
+	If you set coalesceFindRequests to `true` it will instead trigger the following request:
+	```
+	GET /comments?filter[id]=1,2
+	```
+	Setting coalesceFindRequests to `true` also works for `store.find` requests and `belongsTo`
+	relationships accessed within the same runloop. If you set `coalesceFindRequests: true`
+	```javascript
+	store.findRecord('comment', 1);
+	store.findRecord('comment', 2);
+	```
+	will also send a request to: `GET /comments?filter[id]=1,2`
+	Note: Requests coalescing rely on URL building strategy. So if you override `buildURL` in your app
+	`groupRecordsForFindMany` more likely should be overridden as well in order for coalescing to work.
+	@property coalesceFindRequests
+	@public
+	@type {Boolean}
+	*/
+	get coalesceFindRequests() {
+		const coalesceFindRequests = this._coalesceFindRequests;
+		if (typeof coalesceFindRequests === "boolean") return coalesceFindRequests;
+		return this._coalesceFindRequests = false;
+	}
+	set coalesceFindRequests(value) {
+		this._coalesceFindRequests = value;
+	}
+	findMany(store, type, ids, snapshots) {
+		const url = this.buildURL(type.modelName, ids, snapshots, "findMany");
+		return this.ajax(url, "GET", { data: { filter: { id: ids.join(",") } } });
+	}
+	/**
+	* 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);
+	}
+	updateRecord(store, schema, snapshot) {
+		const data = serializeIntoHash(store, schema, snapshot);
+		const type = snapshot.modelName;
+		const id = snapshot.id;
+		macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) && ((test) => {
+			if (!test) throw new Error(`Attempted to update the ${type} record, but the record has no id`);
+		})(typeof id === "string" && id.length > 0);
+		const url = this.buildURL(type, id, snapshot, "updateRecord");
+		return this.ajax(url, "PATCH", { data });
+	}
+	/**
+	Used by `findAll` and `findRecord` to build the query's `data` hash
+	supplied to the ajax method.
+	@since 2.5.0
+	@public
+	@param  {Snapshot} snapshot
+	@return {Object}
+	*/
+	buildQuery(snapshot) {
+		const query = {};
+		if (snapshot) {
+			const { include } = snapshot;
+			const normalizedInclude = Array.isArray(include) ? include.join(",") : include;
+			if (normalizedInclude) query.include = normalizedInclude;
+		}
+		return query;
+	}
+};
+
+//#endregion
+export { JSONAPIAdapter };
+//# sourceMappingURL=json-api.js.map

package/dist/adapter/json-api.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-api.js","names":["dasherize","pluralize","serializeIntoHash","RESTAdapter","macroCondition","getGlobalConfig","JSONAPIAdapter","_defaultContentType","ajaxOptions","url","type","options","hash","headers","coalesceFindRequests","_coalesceFindRequests","value","findMany","store","ids","snapshots","buildURL","modelName","ajax","data","filter","id","join","pathForType","dasherized","updateRecord","schema","snapshot","WarpDrive","env","DEBUG","test","Error","length","buildQuery","query","include","normalizedInclude","Array","isArray"],"sources":["../../src/adapter/json-api.ts"],"sourcesContent":["// oxlint-disable-next-line no-unused-vars\nimport type { RequestManager, Store } from '@warp-drive/core';\nimport { assert } from '@warp-drive/core/build-config/macros';\n// oxlint-disable-next-line no-unused-vars\nimport type { Handler } from '@warp-drive/core/request';\nimport type { ModelSchema } from '@warp-drive/core/types';\nimport type { HTTPMethod } from '@warp-drive/core/types/request';\nimport { dasherize, pluralize } from '@warp-drive/utilities/string';\n\nimport type { AdapterPayload } from '../compat.ts';\nimport type { Snapshot, SnapshotRecordArray } from '../compat/-private.ts';\nimport { serializeIntoHash } from './-private.ts';\nimport type { FetchRequestInit, JQueryRequestInit, QueryState } from './rest.ts';\nimport { RESTAdapter } from './rest.ts';\n/**\n  ## Overview\n\n  :::danger\n    ⚠️ **This is LEGACY documentation** for a feature that is no longer encouraged to be used.\n    If starting a new app or thinking of implementing a new adapter, consider writing a\n    {@link Handler} instead to be used with the {@link RequestManager}\n  :::\n\n  The `JSONAPIAdapter` is an adapter whichtransforms the store's\n  requests into HTTP requests that follow the [JSON API format](http://jsonapi.org/format/).\n\n  ## JSON API Conventions\n\n  The JSONAPIAdapter uses JSON API conventions for building the URL\n  for a record and selecting the HTTP verb to use with a request. The\n  actions you can take on a record map onto the following URLs in the\n  JSON API adapter:\n\n<table>\n  <tr>\n    <th>\n      Action\n    </th>\n    <th>\n      HTTP Verb\n    </th>\n    <th>\n      URL\n    </th>\n  </tr>\n  <tr>\n    <th>\n      `store.findRecord('post', 123)`\n    </th>\n    <td>\n      GET\n    </td>\n    <td>\n      /posts/123\n    </td>\n  </tr>\n  <tr>\n    <th>\n      `store.findAll('post')`\n    </th>\n    <td>\n      GET\n    </td>\n    <td>\n      /posts\n    </td>\n  </tr>\n  <tr>\n    <th>\n      Update `postRecord.save()`\n    </th>\n    <td>\n      PATCH\n    </td>\n    <td>\n      /posts/123\n    </td>\n  </tr>\n  <tr>\n    <th>\n      Create `store.createRecord('post').save()`\n    </th>\n    <td>\n      POST\n    </td>\n    <td>\n      /posts\n    </td>\n  </tr>\n  <tr>\n    <th>\n      Delete `postRecord.destroyRecord()`\n    </th>\n    <td>\n      DELETE\n    </td>\n    <td>\n      /posts/123\n    </td>\n  </tr>\n</table>\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  ```js [app/adapters/application.js]\n  import { JSONAPIAdapter } from '@warp-drive/legacy/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  ```js [app/adapters/application.js]\n  import JSONAPIAdapter from '@warp-drive/legacy/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  @public\n  @constructor\n*/\nclass JSONAPIAdapter extends RESTAdapter {\n  /**\n   * The `Content-Type` header used when serializing request bodies\n   * that don't otherwise specify one.\n   */\n  _defaultContentType = 'application/vnd.api+json';\n\n  /**\n    @private\n    @param {String} url\n    @param {String} type The request type GET, POST, PUT, DELETE etc.\n    @param {Object} options\n    @return {Object}\n  */\n  ajaxOptions(\n    url: string,\n    type: HTTPMethod,\n    options: JQueryAjaxSettings | RequestInit = {}\n  ): JQueryRequestInit | FetchRequestInit {\n    const hash = super.ajaxOptions(url, type, options) as FetchRequestInit;\n    const headers: HeadersInit = (hash.headers = hash.headers || {});\n    headers['Accept'] = (headers['Accept'] as string) || 'application/vnd.api+json';\n\n    return hash;\n  }\n\n  /**\n    By default the JSONAPIAdapter will send each find request coming from a `store.find`\n    or from accessing a relationship separately to the server. If your server supports passing\n    ids as a query string, you can set coalesceFindRequests to true to coalesce all find requests\n    within a single runloop.\n\n    For example, if you have an initial payload of:\n\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\n    By default calling `post.comments` will trigger the following requests(assuming the\n    comments haven't been loaded before):\n\n    ```\n    GET /comments/1\n    GET /comments/2\n    ```\n\n    If you set coalesceFindRequests to `true` it will instead trigger the following request:\n\n    ```\n    GET /comments?filter[id]=1,2\n    ```\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\n    ```javascript\n    store.findRecord('comment', 1);\n    store.findRecord('comment', 2);\n    ```\n\n    will also send a request to: `GET /comments?filter[id]=1,2`\n\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\n    @property coalesceFindRequests\n    @public\n    @type {Boolean}\n  */\n  get coalesceFindRequests() {\n    const coalesceFindRequests = this._coalesceFindRequests;\n    if (typeof coalesceFindRequests === 'boolean') {\n      return coalesceFindRequests;\n    }\n    return (this._coalesceFindRequests = false);\n  }\n\n  set coalesceFindRequests(value: boolean) {\n    this._coalesceFindRequests = value;\n  }\n\n  findMany(store: Store, type: ModelSchema, ids: string[], snapshots: Snapshot[]): Promise<AdapterPayload> {\n    const url = this.buildURL(type.modelName, ids, snapshots, 'findMany');\n    return this.ajax(url, 'GET', { data: { filter: { id: ids.join(',') } } });\n  }\n\n  /**\n   * Determines the pathname for a given type.\n   *\n   * Unlike the base `BuildURLMixin` implementation, dasherizes (rather\n   * than camelizes) the type name before pluralizing it, per the\n   * {json:api} convention for member names.\n   */\n  pathForType(modelName: string): string {\n    const dasherized = dasherize(modelName);\n    return pluralize(dasherized);\n  }\n\n  updateRecord(store: Store, schema: ModelSchema, snapshot: Snapshot): Promise<AdapterPayload> {\n    const data = serializeIntoHash(store, schema, snapshot);\n    const type = snapshot.modelName;\n    const id = snapshot.id;\n    assert(`Attempted to update the ${type} record, but the record has no id`, typeof id === 'string' && id.length > 0);\n\n    const url = this.buildURL(type, id, snapshot, 'updateRecord');\n\n    return this.ajax(url, 'PATCH', { data: data });\n  }\n\n  /**\n    Used by `findAll` and `findRecord` to build the query's `data` hash\n    supplied to the ajax method.\n\n    @since 2.5.0\n    @public\n    @param  {Snapshot} snapshot\n    @return {Object}\n  */\n  buildQuery(snapshot: Snapshot | SnapshotRecordArray): QueryState {\n    const query: QueryState = {};\n\n    if (snapshot) {\n      const { include } = snapshot;\n      const normalizedInclude = Array.isArray(include) ? include.join(',') : include;\n\n      if (normalizedInclude) {\n        query.include = normalizedInclude;\n      }\n    }\n\n    return query;\n  }\n}\n\nexport { JSONAPIAdapter };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2JA,IAAMM,iBAAN,cAA6BH,YAAY;;;;;CAKvCI,sBAAsB;;;;;;;;CAStBC,YACEC,KACAC,MACAC,UAA4C,CAAC,GACP;EACtC,MAAMC,OAAO,MAAMJ,YAAYC,KAAKC,MAAMC,OAAO;EACjD,MAAME,UAAwBD,KAAKC,UAAUD,KAAKC,WAAW,CAAC;EAC9DA,QAAQ,YAAaA,QAAQ,aAAwB;EAErD,OAAOD;CACT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0DA,IAAIE,uBAAuB;EACzB,MAAMA,uBAAuB,KAAKC;EAClC,IAAI,OAAOD,yBAAyB,WAClC,OAAOA;EAET,OAAQ,KAAKC,wBAAwB;CACvC;CAEA,IAAID,qBAAqBE,OAAgB;EACvC,KAAKD,wBAAwBC;CAC/B;CAEAC,SAASC,OAAcR,MAAmBS,KAAeC,WAAgD;EACvG,MAAMX,MAAM,KAAKY,SAASX,KAAKY,WAAWH,KAAKC,WAAW,UAAU;EACpE,OAAO,KAAKG,KAAKd,KAAK,OAAO,EAAEe,MAAM,EAAEC,QAAQ,EAAEC,IAAIP,IAAIQ,KAAK,GAAG,EAAE,EAAE,EAAE,CAAC;CAC1E;;;;;;;;CASAC,YAAYN,WAA2B;EACrC,MAAMO,aAAa7B,UAAUsB,SAAS;EACtC,OAAOrB,UAAU4B,UAAU;CAC7B;CAEAC,aAAaZ,OAAca,QAAqBC,UAA6C;EAC3F,MAAMR,OAAOtB,kBAAkBgB,OAAOa,QAAQC,QAAQ;EACtD,MAAMtB,OAAOsB,SAASV;EACtB,MAAMI,KAAKM,SAASN;EACpBtB,eAAAC,gBAAA,CAAA,CAAA4B,UAAAC,IAAAC,KAAA,OAAAC,SAAA;GAAA,IAAA,CAAAA,MAAA,MAAA,IAAAC,MAAO,2BAA2B3B,KAAI,kCAAmC;EAAA,EAAA,CAAE,OAAOgB,OAAO,YAAYA,GAAGY,SAAS,CAAC;EAElH,MAAM7B,MAAM,KAAKY,SAASX,MAAMgB,IAAIM,UAAU,cAAc;EAE5D,OAAO,KAAKT,KAAKd,KAAK,SAAS,EAAQe,KAAK,CAAC;CAC/C;;;;;;;;;CAWAe,WAAWP,UAAsD;EAC/D,MAAMQ,QAAoB,CAAC;EAE3B,IAAIR,UAAU;GACZ,MAAM,EAAES,YAAYT;GACpB,MAAMU,oBAAoBC,MAAMC,QAAQH,OAAO,IAAIA,QAAQd,KAAK,GAAG,IAAIc;GAEvE,IAAIC,mBACFF,MAAMC,UAAUC;EAEpB;EAEA,OAAOF;CACT;AACF"}

package/dist/adapter/rest.d.ts

@@ -0,0 +1,2 @@
+import { a as RequestData, i as RESTAdapter, n as JQueryRequestInit, o as fetchOptions, r as QueryState, t as FetchRequestInit } from "../rest-0NhtexIq.js";
+export { FetchRequestInit, JQueryRequestInit, QueryState, RESTAdapter, RequestData, fetchOptions };