@ember-data/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/addon-main.cjs

@@ -1,5 +1,5 @@
 'use strict';
 
-const { addonShim } = require('@warp-drive/build-config/addon-shim.cjs');
+const { addonShim } = require('@warp-drive/core/addon-shim.cjs');
 
 module.exports = addonShim(__dirname);

package/dist/-private.js

@@ -1,2 +1 @@
-export { C as CacheHandler, k as CollectionRecordArray, I as LiveArray, M as MUTATE, R as RecordArrayManager, v as RelatedCollection, l as SOURCE, G as Signals, S as Store, q as StoreMap, _ as _clearCaches, u as _deprecatingNormalize, h as coerceId, g as constructResource, L as consumeInternalSignal, F as defineNonEnumerableSignal, E as defineSignal, j as ensureStringId, D as entangleSignal, m as fastPush, B as gate, N as getOrCreateInternalSignal, y as getPromiseState, z as getRequestState, f as isDocumentIdentifier, i as isStableIdentifier, w as log, x as logGroup, A as memoized, K as notifyInternalSignal, p as peekCache, H as peekInternalSignal, r as recordIdentifierFor, n as removeRecordDataFor, t as setCacheFor, o as setRecordIdentifier, s as storeFor, J as withSignalStore } from "./request-state-uRtpn0Lc.js";
-export { A as ARRAY_SIGNAL, O as OBJECT_SIGNAL, c as createMemo } from "./configure-BfLLW6GY.js";
+export * from '@warp-drive/core/store/-private';

package/dist/-private.js.map

@@ -1 +1 @@
-{"version":3,"file":"-private.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}
+{"version":3,"file":"-private.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/configure.js

@@ -1 +1 @@
-export { s as setupSignals } from "./configure-BfLLW6GY.js";
+export { setupSignals } from '@warp-drive/core/configure';

package/dist/index.js

@@ -1,5 +1,208 @@
-export { C as CacheHandler, S as default, r as recordIdentifierFor, c as setIdentifierForgetMethod, a as setIdentifierGenerationMethod, d as setIdentifierResetMethod, b as setIdentifierUpdateMethod, e as setKeyInfoForResource, s as storeFor } from "./request-state-uRtpn0Lc.js";
-import '@ember/debug';
-import '@embroider/macros';
-import '@ember-data/request-utils/string';
-import "./configure-BfLLW6GY.js";
+import { deprecate } from '@ember/debug';
+import { macroCondition, getGlobalConfig, dependencySatisfies, importSync } from '@embroider/macros';
+import { setupSignals } from '@warp-drive/core/configure';
+export { CacheHandler, Store as default, recordIdentifierFor, setIdentifierForgetMethod, setIdentifierGenerationMethod, setIdentifierResetMethod, setIdentifierUpdateMethod, setKeyInfoForResource, storeFor } from '@warp-drive/core';
+
+/**
+ * <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 {
+ *   create() {
+ *     return new RequestManager()
+ *       .use([Fetch])
+ *       .useCache(CacheHandler);
+ *   }
+ * }
+ * ```
+ *
+ * *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
+ */
+if (macroCondition(getGlobalConfig().WarpDrive.deprecations.DEPRECATE_TRACKING_PACKAGE)) {
+  let hasEmberDataTracking = false;
+  if (macroCondition(dependencySatisfies('@ember-data/tracking', '*'))) {
+    hasEmberDataTracking = true;
+    // @ts-expect-error
+    const {
+      buildSignalConfig
+    } = importSync('@ember-data/tracking');
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+    setupSignals(buildSignalConfig);
+  }
+  const message = [`Using WarpDrive with EmberJS requires configuring it to use Ember's reactivity system.`, `Previously this was provided by installing the package '@ember-data/tracking', but this package is now deprecated.`, ``, `To resolve this deprecation, follow these steps:`, hasEmberDataTracking ? `- remove "@ember-data/tracking" and (if needed) "@ember-data-types/tracking" from your project in both your package.json and tsconfig.json` : false, `- add "@warp-drive/ember" to your project in both your package.json and tsconfig.json`, '- add the following import to your app.js file:', '', '\t```', `\timport '@warp-drive/ember/install';`, '\t```', ``, '- mark this deprecation as resolved in your project by adding the following to your WarpDrive config in ember-cli-build.js:', '', '\t```', '\tconst { setConfig } = await import("@warp-drive/build-config");', '\tsetConfig(app, __dirname, {', '\t  deprecations: {', '\t    DEPRECATE_TRACKING_PACKAGE: false,', '\t  },', '\t});', '\t```', ``, `For more information, see the Package Unification RFC: https://rfcs.emberjs.com/id/1075-warp-drive-package-unification/`].filter(l => l !== false).join('\n');
+  deprecate(message, false, {
+    id: 'warp-drive.deprecate-tracking-package',
+    until: '6.0.0',
+    for: 'warp-drive',
+    since: {
+      enabled: '5.3.4',
+      available: '4.13'
+    },
+    url: 'https://deprecations.emberjs.com/id/warp-drive.deprecate-tracking-package'
+  });
+}

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;"}
+{"version":3,"file":"index.js","sources":["../src/index.ts"],"sourcesContent":["/**\n * <p align=\"center\">\n *   <img\n *     class=\"project-logo\"\n *     src=\"https://raw.githubusercontent.com/emberjs/data/4612c9354e4c54d53327ec2cf21955075ce21294/ember-data-logo-light.svg#gh-light-mode-only\"\n *     alt=\"EmberData Store\"\n *     width=\"240px\"\n *     title=\"EmberData Store\"\n *     />\n * </p>\n *\n * This package provides [*Ember***Data**](https://github.com/emberjs/data/)'s `Store` class.\n *\n * 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),\n * 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).\n *\n * Optionally, a Store can be configured to hydrate the response data into rich presentation classes.\n *\n * ## Installation\n *\n * If you have installed `ember-data` then you already have this package installed.\n * Otherwise you can install it using your javascript package manager of choice.\n * For instance with [pnpm](https://pnpm.io/)\n *\n * ```\n * pnpm add @ember-data/store\n * ```\n *\n * After installing you will want to configure your first `Store`. Read more below\n * for how to create and configure stores for your application.\n *\n *\n * ## 🔨 Creating A Store\n *\n * 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)\n * 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,\n * and implement `instantiateRecord` to tell the store how to display the data for individual resources.\n *\n * > **Note**\n * > If you are using the package `ember-data` then a JSON:API cache, RequestManager, LegacyNetworkHandler,\n * > and `instantiateRecord` are configured for you by default.\n *\n * ### Configuring A Cache\n *\n * To start, let's install a [JSON:API](https://jsonapi.org/) cache. If your app uses `GraphQL` or `REST` other\n * caches may better fit your data. You can author your own cache by creating one that\n * conforms to the [spec](https://api.emberjs.com/ember-data/release/classes/%3CInterface%3E%20Cache).\n *\n * The package `@ember-data/json-api` provides a [JSON:API](https://jsonapi.org/) cache we can use.\n * After installing it, we can configure the store to use this cache.\n *\n * ```js\n * import Store from '@ember-data/store';\n * import Cache from '@ember-data/json-api';\n *\n * class extends Store {\n *   createCache(storeWrapper) {\n *     return new Cache(storeWrapper);\n *   }\n * }\n * ```\n *\n * Now that we have a `cache` let's setup something to handle fetching\n * and saving data via our API.\n *\n * > **Note**\n * > The `ember-data` package automatically includes and configures\n * > the `@ember-data/json-api` cache for you.\n *\n * ### Handling Requests\n *\n * 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.\n *\n * To start, let's install the `RequestManager` from `@ember-data/request` and the basic `Fetch` handler from ``@ember-data/request/fetch`.\n *\n * > **Note**\n * > 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).\n *\n * ```ts\n * import Store from '@ember-data/store';\n * import RequestManager from '@ember-data/request';\n * import Fetch from '@ember-data/request/fetch';\n *\n * export default class extends Store {\n *   requestManager = new RequestManager()\n *    .use([Fetch]);\n * }\n * ```\n *\n * **Using RequestManager as a Service**\n *\n * Alternatively if you have configured the `RequestManager` to be a service you may re-use it.\n *\n * *app/services/request.js*\n * ```ts\n * import RequestManager from '@ember-data/request';\n * import Fetch from '@ember-data/request/fetch';\n *\n * export default {\n *   create() {\n *     return new RequestManager()\n *       .use([Fetch])\n *       .useCache(CacheHandler);\n *   }\n * }\n * ```\n *\n * *app/services/store.js*\n * ```ts\n * import Store from '@ember-data/store';\n * import { service } from '@ember/service';\n *\n * export default class extends Store {\n *   @service('request') requestManager\n * }\n * ```\n *\n *\n * ### Presenting Data from the Cache\n *\n * Now that we have a source and a cache for our data, we need to configure how\n * the Store delivers that data back to our application. We do this via the hook\n * [instantiateRecord](https://api.emberjs.com/ember-data/release/classes/Store/methods/instantiateRecord%20(hook)?anchor=instantiateRecord%20(hook)),\n * which allows us to transform the data for a resource before handing it to the application.\n *\n * A naive way to present the data would be to return it as JSON. Typically instead\n * this hook will be used to add reactivity and make each unique resource a singleton,\n * ensuring that if the cache updates our presented data will reflect the new state.\n *\n * Below is an example of using the hooks `instantiateRecord` and a `teardownRecord`\n * to provide minimal read-only reactive state for simple resources.\n *\n * ```ts\n * import Store, { recordIdentifierFor } from '@ember-data/store';\n * import { TrackedObject } from 'tracked-built-ins';\n *\n * class extends Store {\n *   instantiateRecord(identifier) {\n *     const { cache, notifications } = this;\n *\n *     // create a TrackedObject with our attributes, id and type\n *     const record = new TrackedObject(Object.assign({}, cache.peek(identifier)));\n *     record.type = identifier.type;\n *     record.id = identifier.id;\n *\n *     notifications.subscribe(identifier, (_, change) => {\n *       if (change === 'attributes') {\n *         Object.assign(record, cache.peek(identifier));\n *       }\n *     });\n *\n *     return record;\n *   }\n * }\n * ```\n *\n * Because `instantiateRecord` is opaque to the nature of the record, an implementation\n * can be anything from a fairly simple object to a robust proxy that intelligently links\n * together associated records through relationships.\n *\n * This also enables creating a record that separates `edit` flows from `create` flows\n * entirely. A record class might choose to implement a `checkout`method that gives access\n * to an editable instance while the primary record continues to be read-only and reflect\n * only persisted (non-mutated) state.\n *\n * Typically you will choose an existing record implementation such as `@ember-data/model`\n * for your application.\n *\n * Because of the boundaries around instantiation and the cache, record implementations\n * should be capable of interop both with each other and with any `Cache`. Due to this,\n * if needed an application can utilize multiple record implementations and multiple cache\n * implementations either to support enhanced features for only a subset of records or to\n * be able to incrementally migrate from one record/cache to another record or cache.\n *\n * > **Note**\n * > The `ember-data` package automatically includes the `@ember-data/model`\n * > package and configures it for you.\n *\n * @module\n */\nimport { deprecate } from '@ember/debug';\n\nimport { dependencySatisfies, importSync, macroCondition } from '@embroider/macros';\n\nimport { DEPRECATE_TRACKING_PACKAGE } from '@warp-drive/core/build-config/deprecations';\nimport { setupSignals } from '@warp-drive/core/configure';\n\nexport {\n  Store as default,\n  type StoreRequestContext,\n  CacheHandler,\n  type Document,\n  type CachePolicy,\n  type StoreRequestInput,\n  recordIdentifierFor,\n  storeFor,\n  type DocumentCacheOperation,\n  type CacheOperation,\n  type NotificationType,\n  setIdentifierGenerationMethod,\n  setIdentifierUpdateMethod,\n  setIdentifierForgetMethod,\n  setIdentifierResetMethod,\n  setKeyInfoForResource,\n} from '@warp-drive/core';\n\nif (DEPRECATE_TRACKING_PACKAGE) {\n  let hasEmberDataTracking = false;\n  if (macroCondition(dependencySatisfies('@ember-data/tracking', '*'))) {\n    hasEmberDataTracking = true;\n    // @ts-expect-error\n    const { buildSignalConfig } = importSync('@ember-data/tracking');\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument\n    setupSignals(buildSignalConfig);\n  }\n\n  const message = [\n    `Using WarpDrive with EmberJS requires configuring it to use Ember's reactivity system.`,\n    `Previously this was provided by installing the package '@ember-data/tracking', but this package is now deprecated.`,\n    ``,\n    `To resolve this deprecation, follow these steps:`,\n    hasEmberDataTracking\n      ? `- remove \"@ember-data/tracking\" and (if needed) \"@ember-data-types/tracking\" from your project in both your package.json and tsconfig.json`\n      : false,\n    `- add \"@warp-drive/ember\" to your project in both your package.json and tsconfig.json`,\n    '- add the following import to your app.js file:',\n    '',\n    '\\t```',\n    `\\timport '@warp-drive/ember/install';`,\n    '\\t```',\n    ``,\n    '- mark this deprecation as resolved in your project by adding the following to your WarpDrive config in ember-cli-build.js:',\n    '',\n    '\\t```',\n    '\\tconst { setConfig } = await import(\"@warp-drive/build-config\");',\n    '\\tsetConfig(app, __dirname, {',\n    '\\t  deprecations: {',\n    '\\t    DEPRECATE_TRACKING_PACKAGE: false,',\n    '\\t  },',\n    '\\t});',\n    '\\t```',\n    ``,\n    `For more information, see the Package Unification RFC: https://rfcs.emberjs.com/id/1075-warp-drive-package-unification/`,\n  ]\n    .filter((l) => l !== false)\n    .join('\\n');\n\n  deprecate(message, false, {\n    id: 'warp-drive.deprecate-tracking-package',\n    until: '6.0.0',\n    for: 'warp-drive',\n    since: {\n      enabled: '5.3.4',\n      available: '4.13',\n    },\n    url: 'https://deprecations.emberjs.com/id/warp-drive.deprecate-tracking-package',\n  });\n}\n"],"names":["macroCondition","getGlobalConfig","WarpDrive","deprecations","DEPRECATE_TRACKING_PACKAGE","hasEmberDataTracking","dependencySatisfies","buildSignalConfig","importSync","setupSignals","message","filter","l","join","deprecate","id","until","for","since","enabled","available","url"],"mappings":";;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AA2BA,IAAAA,cAAA,CAAAC,eAAA,EAAA,CAAAC,SAAA,CAAAC,YAAA,CAAAC,0BAAA,CAAgC,EAAA;EAC9B,IAAIC,oBAAoB,GAAG,KAAK;EAChC,IAAIL,cAAc,CAACM,mBAAmB,CAAC,sBAAsB,EAAE,GAAG,CAAC,CAAC,EAAE;AACpED,IAAAA,oBAAoB,GAAG,IAAI;AAC3B;IACA,MAAM;AAAEE,MAAAA;AAAkB,KAAC,GAAGC,UAAU,CAAC,sBAAsB,CAAC;AAChE;IACAC,YAAY,CAACF,iBAAiB,CAAC;AACjC;AAEA,EAAA,MAAMG,OAAO,GAAG,CACd,CAAA,sFAAA,CAAwF,EACxF,CAAoH,kHAAA,CAAA,EACpH,CAAE,CAAA,EACF,CAAkD,gDAAA,CAAA,EAClDL,oBAAoB,GAChB,4IAA4I,GAC5I,KAAK,EACT,CAAA,qFAAA,CAAuF,EACvF,iDAAiD,EACjD,EAAE,EACF,OAAO,EACP,CAAuC,qCAAA,CAAA,EACvC,OAAO,EACP,CAAE,CAAA,EACF,6HAA6H,EAC7H,EAAE,EACF,OAAO,EACP,mEAAmE,EACnE,+BAA+B,EAC/B,qBAAqB,EACrB,0CAA0C,EAC1C,QAAQ,EACR,OAAO,EACP,OAAO,EACP,CAAA,CAAE,EACF,CAAA,uHAAA,CAAyH,CAC1H,CACEM,MAAM,CAAEC,CAAC,IAAKA,CAAC,KAAK,KAAK,CAAC,CAC1BC,IAAI,CAAC,IAAI,CAAC;AAEbC,EAAAA,SAAS,CAACJ,OAAO,EAAE,KAAK,EAAE;AACxBK,IAAAA,EAAE,EAAE,uCAAuC;AAC3CC,IAAAA,KAAK,EAAE,OAAO;AACdC,IAAAA,GAAG,EAAE,YAAY;AACjBC,IAAAA,KAAK,EAAE;AACLC,MAAAA,OAAO,EAAE,OAAO;AAChBC,MAAAA,SAAS,EAAE;KACZ;AACDC,IAAAA,GAAG,EAAE;AACP,GAAC,CAAC;AACJ"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ember-data/store",
-  "version": "5.6.0-alpha.0",
+  "version": "5.6.0-alpha.11",
   "description": "The core of EmberData. Provides the Store service which coordinates the cache with the network and presentation layers.",
   "keywords": [
     "ember-addon"
@@ -33,20 +33,17 @@
   },
   "dependencies": {
     "@embroider/macros": "^1.16.12",
-    "@warp-drive/build-config": "5.6.0-alpha.0"
+    "@warp-drive/core": "5.6.0-alpha.11"
   },
   "peerDependencies": {
-    "ember-source": "3.28.12 || ^4.0.4 || ^5.0.0 || ^6.0.0",
-    "@ember-data/request": "5.6.0-alpha.0",
-    "@ember-data/request-utils": "5.6.0-alpha.0",
-    "@warp-drive/core-types": "5.6.0-alpha.0",
-    "@ember-data/tracking": "5.6.0-alpha.0"
+    "@ember-data/tracking": "5.6.0-alpha.11",
+    "@ember/test-waiters": "^3.1.0 || ^4.0.0"
   },
   "peerDependenciesMeta": {
     "@ember-data/tracking": {
       "optional": true
     },
-    "ember-source": {
+    "@ember/test-waiters": {
       "optional": true
     }
   },
@@ -55,21 +52,13 @@
     "@babel/plugin-transform-typescript": "^7.27.0",
     "@babel/preset-env": "^7.26.9",
     "@babel/preset-typescript": "^7.27.0",
-    "@ember-data/request": "5.6.0-alpha.0",
-    "@ember-data/request-utils": "5.6.0-alpha.0",
-    "@glimmer/component": "^2.0.0",
-    "@warp-drive/core-types": "5.6.0-alpha.0",
-    "@warp-drive/internal-config": "5.6.0-alpha.0",
-    "@ember-data/tracking": "5.6.0-alpha.0",
-    "decorator-transforms": "^2.3.0",
+    "@warp-drive/internal-config": "5.6.0-alpha.11",
+    "@ember-data/tracking": "5.6.0-alpha.11",
+    "@ember/test-waiters": "^4.1.0",
     "ember-source": "~6.3.0",
-    "expect-type": "^1.2.1",
     "typescript": "^5.8.3",
     "vite": "^5.4.15"
   },
-  "engines": {
-    "node": ">= 18.20.8"
-  },
   "volta": {
     "extends": "../../package.json"
   },

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"}