@ember-data-types/store 5.6.0-alpha.0 → 5.6.0-alpha.11

package/README.md

@@ -124,11 +124,11 @@ import RequestManager from '@ember-data/request';
 import { CacheHandler } from '@ember-data/store';
 import Fetch from '@ember-data/request/fetch';
 
-export default class extends RequestManager {
-  constructor(createArgs) {
-    super(createArgs);
-    this.use([Fetch]);
-    this.useCache(CacheHandler);
+export default {
+  create() {
+    return new RequestManager()
+      .use([Fetch])
+      .useCache(CacheHandler);
   }
 }
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ember-data-types/store",
-  "version": "5.6.0-alpha.0",
+  "version": "5.6.0-alpha.11",
   "files": [
     "unstable-preview-types",
     "README.md",

package/unstable-preview-types/-private.d.ts

@@ -1,33 +1,4 @@
 declare module '@ember-data/store/-private' {
-  /**
-    @module @ember-data/store
-  */
-  export { Store, storeFor } from '@ember-data/store/-private/store-service';
-  export { recordIdentifierFor } from '@ember-data/store/-private/caches/instance-cache';
-  export { CacheHandler, type StoreRequestContext } from '@ember-data/store/-private/cache-handler/handler';
-  export { type CachePolicy } from '@ember-data/store/-private/cache-handler/types';
-  export { isStableIdentifier, isDocumentIdentifier } from '@ember-data/store/-private/caches/identifier-cache';
-  export { constructResource } from '@ember-data/store/-private/utils/construct-resource';
-  export type { ReactiveDocument as Document } from '@ember-data/store/-private/document';
-  export type { InstanceCache } from '@ember-data/store/-private/caches/instance-cache';
-  export type { FindRecordQuery, Request, SaveRecordMutation, RequestCacheRequestState, RequestStateService, } from '@ember-data/store/-private/network/request-cache';
-  export type { CreateRecordProperties } from '@ember-data/store/-private/store-service';
-  export { coerceId, ensureStringId } from '@ember-data/store/-private/utils/coerce-id';
-  export type { NativeProxy } from '@ember-data/store/-private/record-arrays/native-proxy-type-fix';
-  export { IdentifierArray as LiveArray, Collection as CollectionRecordArray, SOURCE, MUTATE, } from '@ember-data/store/-private/record-arrays/identifier-array';
-  export { RecordArrayManager, fastPush } from '@ember-data/store/-private/managers/record-array-manager';
-  export { _clearCaches } from '@ember-data/store/-private/caches/instance-cache';
-  export { peekCache, removeRecordDataFor } from '@ember-data/store/-private/caches/cache-utils';
-  export { setRecordIdentifier, StoreMap } from '@ember-data/store/-private/caches/instance-cache';
-  export { setCacheFor } from '@ember-data/store/-private/caches/cache-utils';
-  export { normalizeModelName as _deprecatingNormalize } from '@ember-data/store/-private/utils/normalize-model-name';
-  export type { StoreRequestInput } from '@ember-data/store/-private/cache-handler/handler';
-  export { RelatedCollection } from '@ember-data/store/-private/record-arrays/many-array';
-  export { log, logGroup } from '@ember-data/store/-private/debug/utils';
-  export { getPromiseState, type PromiseState } from '@ember-data/store/-private/new-core-tmp/promise-state';
-  export { getRequestState, type RequestLoadingState, type RequestCacheRequestState as RequestState, } from '@ember-data/store/-private/new-core-tmp/request-state';
-  export { createMemo, type SignalHooks } from '@ember-data/store/-private/new-core-tmp/reactivity/configure';
-  export { memoized, gate, entangleSignal, defineSignal, defineNonEnumerableSignal, } from '@ember-data/store/-private/new-core-tmp/reactivity/signal';
-  export { ARRAY_SIGNAL, OBJECT_SIGNAL, Signals, type WarpDriveSignal, peekInternalSignal, withSignalStore, notifyInternalSignal, consumeInternalSignal, getOrCreateInternalSignal, } from '@ember-data/store/-private/new-core-tmp/reactivity/internal';
+  export * from '@warp-drive/core/store/-private';
 }
 //# sourceMappingURL=-private.d.ts.map

package/unstable-preview-types/-private.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"-private.d.ts","sourceRoot":"","sources":["../src/-private.ts"],"names":[],"mappings":"AAAA;;EAEE;AAEF,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAE3D,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AAEvE,OAAO,EAAE,YAAY,EAAE,KAAK,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AAC1F,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAElE,OAAO,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAE9F,OAAO,EAAE,iBAAiB,EAAE,MAAM,qCAAqC,CAAC;AAExE,YAAY,EAAE,gBAAgB,IAAI,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AACxE,YAAY,EAAE,aAAa,EAAE,MAAM,kCAAkC,CAAC;AAEtE,YAAY,EACV,eAAe,EACf,OAAO,EACP,kBAAkB,EAClB,wBAAwB,EACxB,mBAAmB,GACpB,MAAM,kCAAkC,CAAC;AAE1C,YAAY,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAIvE,OAAO,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AACtE,YAAY,EAAE,WAAW,EAAE,MAAM,gDAAgD,CAAC;AAClF,OAAO,EACL,eAAe,IAAI,SAAS,EAC5B,UAAU,IAAI,qBAAqB,EACnC,MAAM,EACN,MAAM,GACP,MAAM,2CAA2C,CAAC;AACnD,OAAO,EAAE,kBAAkB,EAAE,QAAQ,EAAE,MAAM,0CAA0C,CAAC;AAGxF,OAAO,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAChE,OAAO,EAAE,SAAS,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AAG/E,OAAO,EAAE,mBAAmB,EAAE,QAAQ,EAAE,MAAM,kCAAkC,CAAC;AACjF,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAC5D,OAAO,EAAE,kBAAkB,IAAI,qBAAqB,EAAE,MAAM,uCAAuC,CAAC;AACpG,YAAY,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AAC1E,OAAO,EAAE,iBAAiB,EAAE,MAAM,qCAAqC,CAAC;AAExE,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,eAAe,EAAE,KAAK,YAAY,EAAE,MAAM,uCAAuC,CAAC;AAC3F,OAAO,EACL,eAAe,EACf,KAAK,mBAAmB,EACxB,KAAK,wBAAwB,IAAI,YAAY,GAC9C,MAAM,uCAAuC,CAAC;AAE/C,OAAO,EAAE,UAAU,EAAE,KAAK,WAAW,EAAE,MAAM,8CAA8C,CAAC;AAC5F,OAAO,EACL,QAAQ,EACR,IAAI,EACJ,cAAc,EACd,YAAY,EACZ,yBAAyB,GAC1B,MAAM,2CAA2C,CAAC;AACnD,OAAO,EACL,YAAY,EACZ,aAAa,EACb,OAAO,EACP,KAAK,eAAe,EACpB,kBAAkB,EAClB,eAAe,EACf,oBAAoB,EACpB,qBAAqB,EACrB,yBAAyB,GAC1B,MAAM,6CAA6C,CAAC"}
+{"version":3,"file":"-private.d.ts","sourceRoot":"","sources":["../src/-private.ts"],"names":[],"mappings":"AAAA,cAAc,iCAAiC,CAAC"}

package/unstable-preview-types/configure.d.ts

@@ -3,19 +3,15 @@ declare module '@ember-data/store/configure' {
    * Provides a configuration API for the reactivity system
    * that WarpDrive should use.
    *
-   * @module @ember-data/store/configure
-   * @main @ember-data/store/configure
+   * @module
    */
   /**
    * Configures the signals implementation to use. Supports multiple
    * implementations simultaneously.
    *
-   * @method setupSignals
-   * @static
-   * @for @ember-data/store/configure
    * @public
    * @param {function} buildConfig - a function that takes options and returns a configuration object
    */
-  export { setupSignals } from '@ember-data/store/-private/new-core-tmp/reactivity/configure';
+  export { setupSignals } from '@warp-drive/core/configure';
 }
 //# sourceMappingURL=configure.d.ts.map

package/unstable-preview-types/configure.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"configure.d.ts","sourceRoot":"","sources":["../src/configure.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH;;;;;;;;;GASG;AACH,OAAO,EAAE,YAAY,EAAE,MAAM,8CAA8C,CAAC"}
+{"version":3,"file":"configure.d.ts","sourceRoot":"","sources":["../src/configure.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH;;;;;;GAMG;AACH,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC"}

package/unstable-preview-types/index.d.ts

@@ -1,229 +1,7 @@
-/// <reference path="./types.d.ts" />
 /// <reference path="./configure.d.ts" />
 /// <reference path="./-private.d.ts" />
-/// <reference path="./-types/overview.d.ts" />
-/// <reference path="./-types/q/store.d.ts" />
-/// <reference path="./-types/q/identifier.d.ts" />
-/// <reference path="./-types/q/promise-proxies.d.ts" />
-/// <reference path="./-types/q/schema-service.d.ts" />
-/// <reference path="./-types/q/record-instance.d.ts" />
-/// <reference path="./-types/q/record-data-json-api.d.ts" />
-/// <reference path="./-types/q/cache-capabilities-manager.d.ts" />
-/// <reference path="./-types/q/ds-model.d.ts" />
-/// <reference path="./-private/store-service.d.ts" />
-/// <reference path="./-private/store-service.type-test.d.ts" />
-/// <reference path="./-private/document.d.ts" />
-/// <reference path="./-private/caches/cache-utils.d.ts" />
-/// <reference path="./-private/caches/resource-utils.d.ts" />
-/// <reference path="./-private/caches/instance-cache.d.ts" />
-/// <reference path="./-private/caches/identifier-cache.d.ts" />
-/// <reference path="./-private/legacy-model-support/shim-model-class.d.ts" />
-/// <reference path="./-private/legacy-model-support/record-reference.d.ts" />
-/// <reference path="./-private/managers/notification-manager.d.ts" />
-/// <reference path="./-private/managers/record-array-manager.d.ts" />
-/// <reference path="./-private/managers/cache-capabilities-manager.d.ts" />
-/// <reference path="./-private/managers/cache-manager.d.ts" />
-/// <reference path="./-private/new-core-tmp/request-state.d.ts" />
-/// <reference path="./-private/new-core-tmp/promise-state.d.ts" />
-/// <reference path="./-private/new-core-tmp/reactivity/internal.d.ts" />
-/// <reference path="./-private/new-core-tmp/reactivity/signal.d.ts" />
-/// <reference path="./-private/new-core-tmp/reactivity/configure.d.ts" />
-/// <reference path="./-private/debug/utils.d.ts" />
-/// <reference path="./-private/network/request-cache.d.ts" />
-/// <reference path="./-private/cache-handler/utils.d.ts" />
-/// <reference path="./-private/cache-handler/types.d.ts" />
-/// <reference path="./-private/cache-handler/handler.d.ts" />
-/// <reference path="./-private/utils/normalize-model-name.d.ts" />
-/// <reference path="./-private/utils/uuid-polyfill.d.ts" />
-/// <reference path="./-private/utils/construct-resource.d.ts" />
-/// <reference path="./-private/utils/is-non-empty-string.d.ts" />
-/// <reference path="./-private/utils/coerce-id.d.ts" />
-/// <reference path="./-private/record-arrays/identifier-array.d.ts" />
-/// <reference path="./-private/record-arrays/many-array.d.ts" />
-/// <reference path="./-private/record-arrays/native-proxy-type-fix.d.ts" />
+/// <reference path="./types.d.ts" />
 declare module '@ember-data/store' {
-  /**
-   * <p align="center">
-   *   <img
-   *     class="project-logo"
-   *     src="https://raw.githubusercontent.com/emberjs/data/4612c9354e4c54d53327ec2cf21955075ce21294/ember-data-logo-light.svg#gh-light-mode-only"
-   *     alt="EmberData Store"
-   *     width="240px"
-   *     title="EmberData Store"
-   *     />
-   * </p>
-   *
-   * This package provides [*Ember***Data**](https://github.com/emberjs/data/)'s `Store` class.
-   *
-   * A [Store](https://api.emberjs.com/ember-data/release/classes/Store) coordinates interaction between your application, a [Cache](https://api.emberjs.com/ember-data/release/classes/%3CInterface%3E%20Cache),
-   * and sources of data (such as your API or a local persistence layer) accessed via a [RequestManager](https://github.com/emberjs/data/tree/main/packages/request).
-   *
-   * Optionally, a Store can be configured to hydrate the response data into rich presentation classes.
-   *
-   * ## Installation
-   *
-   * If you have installed `ember-data` then you already have this package installed.
-   * Otherwise you can install it using your javascript package manager of choice.
-   * For instance with [pnpm](https://pnpm.io/)
-   *
-   * ```
-   * pnpm add @ember-data/store
-   * ```
-   *
-   * After installing you will want to configure your first `Store`. Read more below
-   * for how to create and configure stores for your application.
-   *
-   *
-   * ## 🔨 Creating A Store
-   *
-   * To use a `Store` we will need to do few things: add a [Cache](https://api.emberjs.com/ember-data/release/classes/%3CInterface%3E%20Cache)
-   * to store data **in-memory**, add a [Handler](https://api.emberjs.com/ember-data/release/classes/%3CInterface%3E%20Cache) to fetch data from a source,
-   * and implement `instantiateRecord` to tell the store how to display the data for individual resources.
-   *
-   * > **Note**
-   * > If you are using the package `ember-data` then a JSON:API cache, RequestManager, LegacyNetworkHandler,
-   * > and `instantiateRecord` are configured for you by default.
-   *
-   * ### Configuring A Cache
-   *
-   * To start, let's install a [JSON:API](https://jsonapi.org/) cache. If your app uses `GraphQL` or `REST` other
-   * caches may better fit your data. You can author your own cache by creating one that
-   * conforms to the [spec](https://api.emberjs.com/ember-data/release/classes/%3CInterface%3E%20Cache).
-   *
-   * The package `@ember-data/json-api` provides a [JSON:API](https://jsonapi.org/) cache we can use.
-   * After installing it, we can configure the store to use this cache.
-   *
-   * ```js
-   * import Store from '@ember-data/store';
-   * import Cache from '@ember-data/json-api';
-   *
-   * class extends Store {
-   *   createCache(storeWrapper) {
-   *     return new Cache(storeWrapper);
-   *   }
-   * }
-   * ```
-   *
-   * Now that we have a `cache` let's setup something to handle fetching
-   * and saving data via our API.
-   *
-   * > **Note**
-   * > The `ember-data` package automatically includes and configures
-   * > the `@ember-data/json-api` cache for you.
-   *
-   * ### Handling Requests
-   *
-   * When *Ember***Data** needs to fetch or save data it will pass that request to your application's `RequestManager` for fulfillment. How this fulfillment occurs (in-memory, device storage, via single or multiple API requests, etc.) is then up to the registered request handlers.
-   *
-   * To start, let's install the `RequestManager` from `@ember-data/request` and the basic `Fetch` handler from ``@ember-data/request/fetch`.
-   *
-   * > **Note**
-   * > If your app uses `GraphQL`, `REST` or different conventions for `JSON:API` than your cache expects, other handlers may better fit your data. You can author your own handler by creating one that conforms to the [handler interface](https://github.com/emberjs/data/tree/main/packages/request#handling-requests).
-   *
-   * ```ts
-   * import Store from '@ember-data/store';
-   * import RequestManager from '@ember-data/request';
-   * import Fetch from '@ember-data/request/fetch';
-   *
-   * export default class extends Store {
-   *   requestManager = new RequestManager()
-   *    .use([Fetch]);
-   * }
-   * ```
-   *
-   * **Using RequestManager as a Service**
-   *
-   * Alternatively if you have configured the `RequestManager` to be a service you may re-use it.
-   *
-   * *app/services/request.js*
-   * ```ts
-   * import RequestManager from '@ember-data/request';
-   * import Fetch from '@ember-data/request/fetch';
-   *
-   * export default class extends RequestManager {
-   *   constructor(createArgs) {
-   *     super(createArgs);
-   *     this.use([Fetch]);
-   *   }
-   * }
-   * ```
-   *
-   * *app/services/store.js*
-   * ```ts
-   * import Store from '@ember-data/store';
-   * import { service } from '@ember/service';
-   *
-   * export default class extends Store {
-   *   @service('request') requestManager
-   * }
-   * ```
-   *
-   *
-   * ### Presenting Data from the Cache
-   *
-   * Now that we have a source and a cache for our data, we need to configure how
-   * the Store delivers that data back to our application. We do this via the hook
-   * [instantiateRecord](https://api.emberjs.com/ember-data/release/classes/Store/methods/instantiateRecord%20(hook)?anchor=instantiateRecord%20(hook)),
-   * which allows us to transform the data for a resource before handing it to the application.
-   *
-   * A naive way to present the data would be to return it as JSON. Typically instead
-   * this hook will be used to add reactivity and make each unique resource a singleton,
-   * ensuring that if the cache updates our presented data will reflect the new state.
-   *
-   * Below is an example of using the hooks `instantiateRecord` and a `teardownRecord`
-   * to provide minimal read-only reactive state for simple resources.
-   *
-   * ```ts
-   * import Store, { recordIdentifierFor } from '@ember-data/store';
-   * import { TrackedObject } from 'tracked-built-ins';
-   *
-   * class extends Store {
-   *   instantiateRecord(identifier) {
-   *     const { cache, notifications } = this;
-   *
-   *     // create a TrackedObject with our attributes, id and type
-   *     const record = new TrackedObject(Object.assign({}, cache.peek(identifier)));
-   *     record.type = identifier.type;
-   *     record.id = identifier.id;
-   *
-   *     notifications.subscribe(identifier, (_, change) => {
-   *       if (change === 'attributes') {
-   *         Object.assign(record, cache.peek(identifier));
-   *       }
-   *     });
-   *
-   *     return record;
-   *   }
-   * }
-   * ```
-   *
-   * Because `instantiateRecord` is opaque to the nature of the record, an implementation
-   * can be anything from a fairly simple object to a robust proxy that intelligently links
-   * together associated records through relationships.
-   *
-   * This also enables creating a record that separates `edit` flows from `create` flows
-   * entirely. A record class might choose to implement a `checkout`method that gives access
-   * to an editable instance while the primary record continues to be read-only and reflect
-   * only persisted (non-mutated) state.
-   *
-   * Typically you will choose an existing record implementation such as `@ember-data/model`
-   * for your application.
-   *
-   * Because of the boundaries around instantiation and the cache, record implementations
-   * should be capable of interop both with each other and with any `Cache`. Due to this,
-   * if needed an application can utilize multiple record implementations and multiple cache
-   * implementations either to support enhanced features for only a subset of records or to
-   * be able to incrementally migrate from one record/cache to another record or cache.
-   *
-   * > **Note**
-   * > The `ember-data` package automatically includes the `@ember-data/model`
-   * > package and configures it for you.
-   *
-   * @module @ember-data/store
-   * @main @ember-data/store
-   */
-  export { Store as default, type StoreRequestContext, CacheHandler, type Document, type CachePolicy, type StoreRequestInput, recordIdentifierFor, storeFor, } from '@ember-data/store/-private';
-  export type { DocumentCacheOperation, CacheOperation, NotificationType, } from '@ember-data/store/-private/managers/notification-manager';
-  export { setIdentifierGenerationMethod, setIdentifierUpdateMethod, setIdentifierForgetMethod, setIdentifierResetMethod, setKeyInfoForResource, } from '@ember-data/store/-private/caches/identifier-cache';
+  export { Store as default, type StoreRequestContext, CacheHandler, type Document, type CachePolicy, type StoreRequestInput, recordIdentifierFor, storeFor, type DocumentCacheOperation, type CacheOperation, type NotificationType, setIdentifierGenerationMethod, setIdentifierUpdateMethod, setIdentifierForgetMethod, setIdentifierResetMethod, setKeyInfoForResource, } from '@warp-drive/core';
 }
 //# sourceMappingURL=index.d.ts.map

package/unstable-preview-types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmLG;AACH,OAAO,EACL,KAAK,IAAI,OAAO,EAChB,KAAK,mBAAmB,EACxB,YAAY,EACZ,KAAK,QAAQ,EACb,KAAK,WAAW,EAChB,KAAK,iBAAiB,EACtB,mBAAmB,EACnB,QAAQ,GACT,MAAM,YAAY,CAAC;AAEpB,YAAY,EACV,sBAAsB,EACtB,cAAc,EACd,gBAAgB,GACjB,MAAM,0CAA0C,CAAC;AAElD,OAAO,EACL,6BAA6B,EAC7B,yBAAyB,EACzB,yBAAyB,EACzB,wBAAwB,EACxB,qBAAqB,GACtB,MAAM,oCAAoC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AA2LA,OAAO,EACL,KAAK,IAAI,OAAO,EAChB,KAAK,mBAAmB,EACxB,YAAY,EACZ,KAAK,QAAQ,EACb,KAAK,WAAW,EAChB,KAAK,iBAAiB,EACtB,mBAAmB,EACnB,QAAQ,EACR,KAAK,sBAAsB,EAC3B,KAAK,cAAc,EACnB,KAAK,gBAAgB,EACrB,6BAA6B,EAC7B,yBAAyB,EACzB,yBAAyB,EACzB,wBAAwB,EACxB,qBAAqB,GACtB,MAAM,kBAAkB,CAAC"}

package/unstable-preview-types/types.d.ts

@@ -1,7 +1,4 @@
 declare module '@ember-data/store/types' {
-  export type { CacheCapabilitiesManager } from '@ember-data/store/-types/q/cache-capabilities-manager';
-  export type { ModelSchema } from '@ember-data/store/-types/q/ds-model';
-  export type { SchemaService } from '@ember-data/store/-types/q/schema-service';
-  export type { BaseFinderOptions, FindRecordOptions, LegacyResourceQuery, QueryOptions, FindAllOptions, } from '@ember-data/store/-types/q/store';
+  export type { CacheCapabilitiesManager, ModelSchema, SchemaService, BaseFinderOptions, FindRecordOptions, LegacyResourceQuery, QueryOptions, FindAllOptions, } from '@warp-drive/core/types';
 }
 //# sourceMappingURL=types.d.ts.map

package/unstable-preview-types/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,wBAAwB,EAAE,MAAM,uCAAuC,CAAC;AACtF,YAAY,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AACvD,YAAY,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAC/D,YAAY,EACV,iBAAiB,EACjB,iBAAiB,EACjB,mBAAmB,EACnB,YAAY,EACZ,cAAc,GACf,MAAM,kBAAkB,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,wBAAwB,EACxB,WAAW,EACX,aAAa,EACb,iBAAiB,EACjB,iBAAiB,EACjB,mBAAmB,EACnB,YAAY,EACZ,cAAc,GACf,MAAM,wBAAwB,CAAC"}

package/unstable-preview-types/-private/cache-handler/handler.d.ts

@@ -1,62 +0,0 @@
-declare module '@ember-data/store/-private/cache-handler/handler' {
-  /**
-   * @module @ember-data/store
-   */
-  import type { CacheHandler as CacheHandlerType } from '@ember-data/request';
-  import type { ImmutableRequestInfo, RequestContext } from '@warp-drive/core-types/request';
-  import type { ResourceIdentifierObject } from '@warp-drive/core-types/spec/json-api-raw';
-  import type { Store } from '@ember-data/store/-private/store-service';
-  export type LooseStoreRequestInfo<T = unknown, RT = unknown> = Omit<ImmutableRequestInfo<T, RT>, 'records' | 'headers'> & {
-      records?: ResourceIdentifierObject[];
-      headers?: Headers;
-  };
-  export type StoreRequestInput<T = unknown, RT = unknown> = ImmutableRequestInfo<T, RT> | LooseStoreRequestInfo<T, RT>;
-  export interface StoreRequestContext extends RequestContext {
-      request: ImmutableRequestInfo & {
-          store: Store;
-      };
-  }
-  /**
-   * A CacheHandler that adds support for using an EmberData Cache with a RequestManager.
-   *
-   * This handler will only run when a request has supplied a `store` instance. Requests
-   * issued by the store via `store.request()` will automatically have the `store` instance
-   * attached to the request.
-   *
-   * ```ts
-   * requestManager.request({
-   *   store: store,
-   *   url: '/api/posts',
-   *   method: 'GET'
-   * });
-   * ```
-   *
-   * When this handler elects to handle a request, it will return the raw `StructuredDocument`
-   * unless the request has `[EnableHydration]` set to `true`. In this case, the handler will
-   * return a `Document` instance that will automatically update the UI when the cache is updated
-   * in the future and will hydrate any identifiers in the StructuredDocument into Record instances.
-   *
-   * When issuing a request via the store, [EnableHydration] is automatically set to `true`. This
-   * means that if desired you can issue requests that utilize the cache without needing to also
-   * utilize Record instances if desired.
-   *
-   * Said differently, you could elect to issue all requests via a RequestManager, without ever using
-   * the store directly, by setting [EnableHydration] to `true` and providing a store instance. Not
-   * necessarily the most useful thing, but the decoupled nature of the RequestManager and incremental-feature
-   * approach of EmberData allows for this flexibility.
-   *
-   * ```ts
-   * import { EnableHydration } from '@warp-drive/core-types/request';
-   *
-   * requestManager.request({
-   *   store: store,
-   *   url: '/api/posts',
-   *   method: 'GET',
-   *   [EnableHydration]: true
-   * });
-   *
-   * @typedoc
-   */
-  export const CacheHandler: CacheHandlerType;
-}
-//# sourceMappingURL=handler.d.ts.map

package/unstable-preview-types/-private/cache-handler/handler.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"handler.d.ts","sourceRoot":"","sources":["../../../src/-private/cache-handler/handler.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,EAAE,YAAY,IAAI,gBAAgB,EAAkB,MAAM,qBAAqB,CAAC;AAI5F,OAAO,KAAK,EACV,oBAAoB,EACpB,cAAc,EAGf,MAAM,gCAAgC,CAAC;AAQxC,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,0CAA0C,CAAC;AAGzF,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAU9C,MAAM,MAAM,qBAAqB,CAAC,CAAC,GAAG,OAAO,EAAE,EAAE,GAAG,OAAO,IAAI,IAAI,CACjE,oBAAoB,CAAC,CAAC,EAAE,EAAE,CAAC,EAC3B,SAAS,GAAG,SAAS,CACtB,GAAG;IACF,OAAO,CAAC,EAAE,wBAAwB,EAAE,CAAC;IACrC,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,iBAAiB,CAAC,CAAC,GAAG,OAAO,EAAE,EAAE,GAAG,OAAO,IAAI,oBAAoB,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,qBAAqB,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;AAEtH,MAAM,WAAW,mBAAoB,SAAQ,cAAc;IACzD,OAAO,EAAE,oBAAoB,GAAG;QAAE,KAAK,EAAE,KAAK,CAAA;KAAE,CAAC;CAClD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,eAAO,MAAM,YAAY,EAAE,gBA0E1B,CAAC"}

package/unstable-preview-types/-private/cache-handler/types.d.ts

@@ -1,107 +0,0 @@
-declare module '@ember-data/store/-private/cache-handler/types' {
-  import type { StableDocumentIdentifier } from '@warp-drive/core-types/identifier';
-  import type { ImmutableRequestInfo, ResponseInfo } from '@warp-drive/core-types/request';
-  import type { Store } from '@ember-data/store/-private/store-service';
-  /**
-   * A service which an application may provide to the store via
-   * the store's `lifetimes` property to configure the behavior
-   * of the CacheHandler.
-   *
-   * The default behavior for request lifetimes is to never expire
-   * unless manually refreshed via `cacheOptions.reload` or `cacheOptions.backgroundReload`.
-   *
-   * Implementing this service allows you to programatically define
-   * when a request should be considered expired.
-   *
-   * @class <Interface> CachePolicy
-   * @public
-   */
-  export interface CachePolicy {
-      /**
-       * Invoked to determine if the request may be fulfilled from cache
-       * if possible.
-       *
-       * Note, this is only invoked if the request has a cache-key.
-       *
-       * If no cache entry is found or the entry is hard expired,
-       * the request will be fulfilled from the configured request handlers
-       * and the cache will be updated before returning the response.
-       *
-       * @method isHardExpired
-       * @public
-       * @param {StableDocumentIdentifier} identifier
-       * @param {Store} store
-       * @return {Boolean} true if the request is considered hard expired
-       */
-      isHardExpired(identifier: StableDocumentIdentifier, store: Store): boolean;
-      /**
-       * Invoked if `isHardExpired` is false to determine if the request
-       * should be update behind the scenes if cache data is already available.
-       *
-       * Note, this is only invoked if the request has a cache-key.
-       *
-       * If true, the request will be fulfilled from cache while a backgrounded
-       * request is made to update the cache via the configured request handlers.
-       *
-       * @method isSoftExpired
-       * @public
-       * @param {StableDocumentIdentifier} identifier
-       * @param {Store} store
-       * @return {Boolean} true if the request is considered soft expired
-       */
-      isSoftExpired(identifier: StableDocumentIdentifier, store: Store): boolean;
-      /**
-       * Invoked when a request will be sent to the configured request handlers.
-       * This is invoked for both foreground and background requests.
-       *
-       * Note, this is invoked regardless of whether the request has a cache-key.
-       *
-       * @method willRequest [Optional]
-       * @public
-       * @param {ImmutableRequestInfo} request
-       * @param {StableDocumentIdentifier | null} identifier
-       * @param {Store} store
-       * @return {void}
-       */
-      willRequest?(request: ImmutableRequestInfo, identifier: StableDocumentIdentifier | null, store: Store): void;
-      /**
-       * Invoked when a request has been fulfilled from the configured request handlers.
-       * This is invoked for both foreground and background requests once the cache has
-       * been updated.
-       *
-       * Note, this is invoked regardless of whether the request has a cache-key.
-       *
-       * It is best practice to notify the store of any requests marked as invalidated
-       * so that request subscriptions can reload when needed.
-       *
-       * ```ts
-       * store.notifications.notify(identifier, 'invalidated');
-       * ```
-       *
-       * This allows anything subscribed to the request to be notified of the change
-       *
-       * e.g.
-       *
-       * ```ts
-       * store.notifications.subscribe(identifier, (_, type) => {
-       *   if (type === 'invalidated') {
-       *     // do update
-       *   }
-       * });
-       * ```
-       *
-       * Note,
-       *
-       *
-       * @method didRequest [Optional]
-       * @public
-       * @param {ImmutableRequestInfo} request
-       * @param {ImmutableResponse} response
-       * @param {StableDocumentIdentifier | null} identifier
-       * @param {Store} store
-       * @return {void}
-       */
-      didRequest?(request: ImmutableRequestInfo, response: Response | ResponseInfo | null, identifier: StableDocumentIdentifier | null, store: Store): void;
-  }
-}
-//# sourceMappingURL=types.d.ts.map

package/unstable-preview-types/-private/cache-handler/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/-private/cache-handler/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,mCAAmC,CAAC;AAClF,OAAO,KAAK,EAAE,oBAAoB,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AAEzF,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAE9C;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,WAAW;IAC1B;;;;;;;;;;;;;;;OAeG;IACH,aAAa,CAAC,UAAU,EAAE,wBAAwB,EAAE,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC;IAC3E;;;;;;;;;;;;;;OAcG;IACH,aAAa,CAAC,UAAU,EAAE,wBAAwB,EAAE,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC;IAE3E;;;;;;;;;;;;OAYG;IACH,WAAW,CAAC,CAAC,OAAO,EAAE,oBAAoB,EAAE,UAAU,EAAE,wBAAwB,GAAG,IAAI,EAAE,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IAE7G;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoCG;IACH,UAAU,CAAC,CACT,OAAO,EAAE,oBAAoB,EAC7B,QAAQ,EAAE,QAAQ,GAAG,YAAY,GAAG,IAAI,EACxC,UAAU,EAAE,wBAAwB,GAAG,IAAI,EAC3C,KAAK,EAAE,KAAK,GACX,IAAI,CAAC;CACT"}

package/unstable-preview-types/-private/cache-handler/utils.d.ts

@@ -1,34 +0,0 @@
-declare module '@ember-data/store/-private/cache-handler/utils' {
-  import type { StableDocumentIdentifier } from '@warp-drive/core-types/identifier';
-  import type { ImmutableCreateRequestOptions, ImmutableDeleteRequestOptions, ImmutableRequestInfo, ImmutableUpdateRequestOptions, StructuredDataDocument } from '@warp-drive/core-types/request';
-  import type { ResourceDataDocument, ResourceErrorDocument } from '@warp-drive/core-types/spec/document';
-  import type { ApiError } from '@warp-drive/core-types/spec/error';
-  import type { Store } from '@ember-data/store/-private/store-service';
-  export const MUTATION_OPS: Set<string>;
-  export function calcShouldFetch(store: Store, request: ImmutableRequestInfo, hasCachedValue: boolean, identifier: StableDocumentIdentifier | null): boolean;
-  export function calcShouldBackgroundFetch(store: Store, request: ImmutableRequestInfo, willFetch: boolean, identifier: StableDocumentIdentifier | null): boolean;
-  export function isMutation(request: Partial<ImmutableRequestInfo>): request is ImmutableUpdateRequestOptions | ImmutableCreateRequestOptions | ImmutableDeleteRequestOptions;
-  export function isCacheAffecting<T>(document: StructuredDataDocument<T>): boolean;
-  export function isAggregateError(error: Error & {
-      errors?: ApiError[];
-  }): error is AggregateError & {
-      errors: ApiError[];
-  };
-  export type RobustError = Error & {
-      error: string | object;
-      errors?: ApiError[];
-      content?: unknown;
-  };
-  export function cloneError(error: RobustError): RobustError;
-  export function isErrorDocument(document: ResourceDataDocument | ResourceErrorDocument): document is ResourceErrorDocument;
-  export function getPriority(identifier: StableDocumentIdentifier | null, deduped: Map<StableDocumentIdentifier, {
-      priority: {
-          blocking: boolean;
-      };
-  }>, priority: {
-      blocking: boolean;
-  }): {
-      blocking: boolean;
-  };
-}
-//# sourceMappingURL=utils.d.ts.map

package/unstable-preview-types/-private/cache-handler/utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/-private/cache-handler/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,mCAAmC,CAAC;AAClF,OAAO,KAAK,EACV,6BAA6B,EAC7B,6BAA6B,EAC7B,oBAAoB,EACpB,6BAA6B,EAC7B,sBAAsB,EACvB,MAAM,gCAAgC,CAAC;AACxC,OAAO,KAAK,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,MAAM,sCAAsC,CAAC;AACxG,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mCAAmC,CAAC;AAElE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAE9C,eAAO,MAAM,YAAY,aAA4D,CAAC;AAEtF,wBAAgB,eAAe,CAC7B,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,oBAAoB,EAC7B,cAAc,EAAE,OAAO,EACvB,UAAU,EAAE,wBAAwB,GAAG,IAAI,GAC1C,OAAO,CAQT;AAED,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,oBAAoB,EAC7B,SAAS,EAAE,OAAO,EAClB,UAAU,EAAE,wBAAwB,GAAG,IAAI,GAC1C,OAAO,CAOT;AAED,wBAAgB,UAAU,CACxB,OAAO,EAAE,OAAO,CAAC,oBAAoB,CAAC,GACrC,OAAO,IAAI,6BAA6B,GAAG,6BAA6B,GAAG,6BAA6B,CAE1G;AAED,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,QAAQ,EAAE,sBAAsB,CAAC,CAAC,CAAC,GAAG,OAAO,CAahF;AAED,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,KAAK,GAAG;IAAE,MAAM,CAAC,EAAE,QAAQ,EAAE,CAAA;CAAE,GACrC,KAAK,IAAI,cAAc,GAAG;IAAE,MAAM,EAAE,QAAQ,EAAE,CAAA;CAAE,CAElD;AAED,MAAM,MAAM,WAAW,GAAG,KAAK,GAAG;IAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,QAAQ,EAAE,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC;AAGrG,wBAAgB,UAAU,CAAC,KAAK,EAAE,WAAW,eAa5C;AAED,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,oBAAoB,GAAG,qBAAqB,GACrD,QAAQ,IAAI,qBAAqB,CAEnC;AAED,wBAAgB,WAAW,CACzB,UAAU,EAAE,wBAAwB,GAAG,IAAI,EAC3C,OAAO,EAAE,GAAG,CAAC,wBAAwB,EAAE;IAAE,QAAQ,EAAE;QAAE,QAAQ,EAAE,OAAO,CAAA;KAAE,CAAA;CAAE,CAAC,EAC3E,QAAQ,EAAE;IAAE,QAAQ,EAAE,OAAO,CAAA;CAAE;cADgC,OAAO;EAUvE"}

package/unstable-preview-types/-private/caches/cache-utils.d.ts

@@ -1,11 +0,0 @@
-declare module '@ember-data/store/-private/caches/cache-utils' {
-  import type { Cache } from '@warp-drive/core-types/cache';
-  import type { StableRecordIdentifier } from '@warp-drive/core-types/identifier';
-  import type { OpaqueRecordInstance } from '@ember-data/store/-types/q/record-instance';
-  export const CacheForIdentifierCache: Map<unknown, Cache>;
-  export function setCacheFor(identifier: StableRecordIdentifier | OpaqueRecordInstance, cache: Cache): void;
-  export function removeRecordDataFor(identifier: StableRecordIdentifier | OpaqueRecordInstance): void;
-  export function peekCache(instance: StableRecordIdentifier): Cache | null;
-  export function peekCache(instance: OpaqueRecordInstance): Cache;
-}
-//# sourceMappingURL=cache-utils.d.ts.map

package/unstable-preview-types/-private/caches/cache-utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cache-utils.d.ts","sourceRoot":"","sources":["../../../src/-private/caches/cache-utils.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,8BAA8B,CAAC;AAC1D,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,mCAAmC,CAAC;AAEhF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gCAAgC,CAAC;AAO3E,eAAO,MAAM,uBAAuB,qBAGnC,CAAC;AAEF,wBAAgB,WAAW,CAAC,UAAU,EAAE,sBAAsB,GAAG,oBAAoB,EAAE,KAAK,EAAE,KAAK,GAAG,IAAI,CAMzG;AAED,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,sBAAsB,GAAG,oBAAoB,GAAG,IAAI,CAEnG;AAED,wBAAgB,SAAS,CAAC,QAAQ,EAAE,sBAAsB,GAAG,KAAK,GAAG,IAAI,CAAC;AAC1E,wBAAgB,SAAS,CAAC,QAAQ,EAAE,oBAAoB,GAAG,KAAK,CAAC"}