@warp-drive/core 5.8.0-alpha.30 → 5.8.0-alpha.34

package/declarations/index.d.ts

@@ -18,7 +18,7 @@ export { Fetch, RequestManager };
 export { Store, CacheHandler, type CachePolicy };
 export { type StoreRequestContext, type StoreRequestInput, storeFor } from "./store/-private.js";
 /**
-* @deprecated use `ReactiveDocument` instead
+* @deprecated use {@link ReactiveDocument} instead
 */
 export type Document<T> = ReactiveDocument<T>;
 export type { DocumentCacheOperation, CacheOperation, NotificationType } from "./store/-private/managers/notification-manager.js";
@@ -76,6 +76,11 @@ export interface StoreSetupOptions<T extends Cache = Cache> {
 	*/
 	CAUTION_MEGA_DANGER_ZONE_extensions?: CAUTION_MEGA_DANGER_ZONE_Extension[];
 }
+export declare class ConfiguredStore<T extends {
+	cache: Cache;
+}> extends Store {
+	createCache(capabilities: CacheCapabilitiesManager): T["cache"];
+}
 /**
 * Creates a configured Store class with recommended defaults
 * for schema handling, reactivity, caching, and request management.
@@ -90,4 +95,6 @@ export interface StoreSetupOptions<T extends Cache = Cache> {
 * });
 * ```
 */
-export declare function useRecommendedStore(options: StoreSetupOptions, StoreKlass?: typeof Store): typeof Store;
+export declare function useRecommendedStore<T extends Cache>(options: StoreSetupOptions<T>, StoreKlass?: typeof Store): typeof ConfiguredStore<{
+	cache: T;
+}>;

package/declarations/store/-private/caches/instance-cache.d.ts

@@ -12,7 +12,7 @@ Retrieves the unique referentially-stable {@link ResourceKey}
 assigned to the given record instance.
 
 ```js
-import { recordIdentifierFor } from "@ember-data/store";
+import { recordIdentifierFor } from "@warp-drive/core";
 // ... gain access to a record, for instance with peekRecord or findRecord
 const record = store.peekRecord("user", "1");
 // get the identifier for the record (see docs for ResourceKey)

package/declarations/store/deprecated/-private.d.ts

@@ -42,7 +42,7 @@ export type KeyOrString<T> = keyof T & string extends never ? string : keyof T &
 * "model" class.
 *
 * Only used when using the legacy schema-service implementation
-* for @ember-data/model or when wrapping schema for legacy
+* for @warp-drive/legacy/model or when wrapping schema for legacy
 * Adapters/Serializers.
 *
 */

package/declarations/types/schema/fields.d.ts

@@ -1463,7 +1463,7 @@ export interface LinksModeBelongsToField {
 		polymorphic?: boolean;
 		/**
 		* Whether this field should ever make use of the legacy support infra
-		* from @ember-data/model and the LegacyNetworkMiddleware for adapters and serializers.
+		* from @warp-drive/legacy/model and the LegacyNetworkMiddleware for adapters and serializers.
 		*
 		* MUST be true for PolarisMode + LinksMode
 		*
@@ -1637,7 +1637,7 @@ export interface LegacyHasManyField {
 		polymorphic?: boolean;
 		/**
 		* Whether this field should ever make use of the legacy support infra
-		* from @ember-data/model and the LegacyNetworkMiddleware for adapters and serializers.
+		* from @warp-drive/legacy/model and the LegacyNetworkMiddleware for adapters and serializers.
 		*
 		* When true, none of the legacy support will be utilized. Sync relationships
 		* will be expected to already have all their data. When reloading a sync relationship
@@ -1813,7 +1813,7 @@ export interface LinksModeHasManyField {
 		polymorphic?: boolean;
 		/**
 		* Whether this field should ever make use of the legacy support infra
-		* from @ember-data/model and the LegacyNetworkMiddleware for adapters and serializers.
+		* from @warp-drive/legacy/model and the LegacyNetworkMiddleware for adapters and serializers.
 		*
 		* MUST be true for PolarisMode + LinksMode
 		*

package/declarations/types/schema/schema-service.d.ts

@@ -21,7 +21,7 @@ interface ObjectWithStringTypeProperty {
 * The primary requirement is merely that any information the service needs to correctly
 * respond to an inquest is available by the time it is asked.
 *
-* The `@ember-data/model` package provides an implementation of this service which
+* The `@warp-drive/legacy/model` package provides an implementation of this service which
 * makes use of your model classes as the source of information to respond to queries
 * about resource schema. While this is useful, this may not be ideal for your application.
 * For instance, Schema information could be sideloaded or pre-flighted for API calls,
@@ -32,7 +32,7 @@ interface ObjectWithStringTypeProperty {
 * hook to return an instance of your service.
 *
 * ```ts
-* import Store from '@ember-data/store';
+* import { Store } from '@warp-drive/core';
 * import CustomSchemas from './custom-schemas';
 *
 * export default class extends Store {
@@ -229,7 +229,7 @@ export interface SchemaService {
 	* be a string reference to a `transform`, and `options` which
 	* should be dictionary in which any key:value pairs are permissable.
 	*
-	* For instance, when using `@ember-data/model`, the following attribute
+	* For instance, when using `@warp-drive/legacy/model`, the following attribute
 	* definition:
 	*
 	* ```ts
@@ -283,7 +283,7 @@ export interface SchemaService {
 	* - `options.as` a string representing the abstract type that the concrete side of
 	*    a relationship must specify when fulfilling a polymorphic inverse.
 	*
-	* For example, the following Model using @ember-data/model would generate this relationships
+	* For example, the following Model using @warp-drive/legacy/model would generate this relationships
 	* definition by default:
 	*
 	* ```js

package/dist/{index-CHrZ1B2X.js → index-D4si_DxB.js}

@@ -1884,7 +1884,7 @@ function peekResourceKey(record) {
   assigned to the given record instance.
 
   ```js
-  import { recordIdentifierFor } from "@ember-data/store";
+  import { recordIdentifierFor } from "@warp-drive/core";
   // ... gain access to a record, for instance with peekRecord or findRecord
   const record = store.peekRecord("user", "1");
   // get the identifier for the record (see docs for ResourceKey)
@@ -1900,7 +1900,7 @@ function peekResourceKey(record) {
 function recordIdentifierFor(record) {
   macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
     if (!test) {
-      throw new Error(`${String(record)} is not a record instantiated by @ember-data/store`);
+      throw new Error(`${String(record)} is not a ReactiveResource or Model known to WarpDrive`);
     }
   })(RecordCache.has(record)) : {};
   return RecordCache.get(record);
@@ -5798,7 +5798,7 @@ function _convertPreloadRelationshipToJSON(value, type) {
  * "model" class.
  *
  * Only used when using the legacy schema-service implementation
- * for @ember-data/model or when wrapping schema for legacy
+ * for @warp-drive/legacy/model or when wrapping schema for legacy
  * Adapters/Serializers.
  *
  */
@@ -6018,7 +6018,7 @@ function getShimClass(store, modelName) {
   return shim;
 }
 
-// Mimics the static apis of @ember-data/model
+// Mimics the static apis of @warp-drive/legacy/model
 class ShimModelClass {
   constructor(store, modelName) {
     this.__store = store;
@@ -8629,7 +8629,7 @@ class ManagedArray {
           if (fn === undefined) {
             fn = function () {
               if (!IS_EDITABLE) {
-                throw new Error(`Mutating this array via ${String(prop)} is not allowed because the record is not editable`);
+                throw new Error(`Mutating this array via ${String(prop)} is not allowed because the ReactiveResource is not editable`);
               }
               consumeInternalSignal(_SIGNAL);
               transaction = true;
@@ -8652,7 +8652,12 @@ class ManagedArray {
           if (context.path) {
             errorPath = context.path[context.path.length - 1];
           }
-          throw new Error(`Cannot set ${String(prop)} on ${errorPath} because the record is not editable`);
+          macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+            {
+              throw new Error(`Cannot set ${String(prop)} on ${errorPath} because the ReactiveResource is not editable`);
+            }
+          })() : {};
+          return false;
         }
         if (prop === 'identifier') {
           self.identifier = value;
@@ -9586,7 +9591,12 @@ function setSchemaObjectField(context) {
     });
     for (const key of Object.keys(newValue)) {
       if (!schemaFields.has(key)) {
-        throw new Error(`Field ${key} does not exist on schema object ${context.field.type}`);
+        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+          {
+            throw new Error(`Field ${key} does not exist on schema object ${context.field.type}`);
+          }
+        })() : {};
+        return false;
       }
     }
   } else {
@@ -10139,7 +10149,7 @@ class ReactiveResource {
         if (!context.editable) {
           macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
             {
-              throw new Error(`Cannot set ${String(prop)} on ${context.path !== null ? context.value : resourceKey.type} because the record is not editable`);
+              throw new Error(`Cannot set ${String(prop)} on ${context.path !== null ? context.value : resourceKey.type} because the ReactiveResource is not editable`);
             }
           })() : {};
           return false;
@@ -11675,7 +11685,7 @@ globalThis.getWarpDriveRuntimeConfig = getRuntimeConfig;
  * ```
  */
 function useRecommendedStore(options, StoreKlass = Store) {
-  return class ConfiguredStore extends StoreKlass {
+  return class AppStore extends StoreKlass {
     requestManager = new RequestManager().use([...(options.handlers ?? []), Fetch]).useCache(CacheHandler);
     lifetimes = options.policy ?? new DefaultCachePolicy({
       apiCacheHardExpires: 15 * 60 * 1000,

package/dist/index.js

@@ -1,4 +1,4 @@
-export { C as CacheHandler, V as Fetch, W as RequestManager, S as Store, r as cacheKeyFor, r as recordIdentifierFor, $ as setIdentifierForgetMethod, Y as setIdentifierGenerationMethod, a0 as setIdentifierResetMethod, Z as setIdentifierUpdateMethod, a1 as setKeyInfoForResource, s as storeFor, X as useRecommendedStore } from "./index-CHrZ1B2X.js";
+export { C as CacheHandler, V as Fetch, W as RequestManager, S as Store, r as cacheKeyFor, r as recordIdentifierFor, $ as setIdentifierForgetMethod, Y as setIdentifierGenerationMethod, a0 as setIdentifierResetMethod, Z as setIdentifierUpdateMethod, a1 as setKeyInfoForResource, s as storeFor, X as useRecommendedStore } from "./index-D4si_DxB.js";
 import "./symbols-sql1_mdx.js";
 import '@ember/debug';
 import '@embroider/macros';

package/dist/reactive.js

@@ -1,4 +1,4 @@
-export { N as SchemaService, K as checkout, T as commit, p as createRequestSubscription, P as fromIdentity, U as getPromiseState, q as getRequestState, L as instantiateRecord, Q as registerDerivations, M as teardownRecord, O as withDefaults } from "./index-CHrZ1B2X.js";
+export { N as SchemaService, K as checkout, T as commit, p as createRequestSubscription, P as fromIdentity, U as getPromiseState, q as getRequestState, L as instantiateRecord, Q as registerDerivations, M as teardownRecord, O as withDefaults } from "./index-D4si_DxB.js";
 export { a as Checkout } from "./symbols-sql1_mdx.js";
 import './types/request.js';
 import '@embroider/macros';

package/dist/store/-private.js

@@ -1,2 +1,2 @@
-export { C as CacheHandler, D as DISPOSE, R as RecordArrayManager, B as Signals, S as Store, k as StoreMap, _ as _clearCaches, n as _deprecatingNormalize, h as assertPrivateCapabilities, d as assertPrivateStore, b as coerceId, c as constructResource, I as consumeInternalSignal, F as createInternalMemo, l as createLegacyManyArray, p as createRequestSubscription, z as defineGate, A as defineNonEnumerableSignal, y as defineSignal, e as ensureStringId, x as entangleInitiallyStaleSignal, w as entangleSignal, f as fastPush, v as gate, J as getOrCreateInternalSignal, q as getRequestState, g as isPrivateStore, a as isRequestKey, i as isResourceKey, m as log, o as logGroup, u as memoized, H as notifyInternalSignal, E as peekInternalSignal, r as recordIdentifierFor, j as setRecordIdentifier, t as signal, s as storeFor, G as withSignalStore } from "../index-CHrZ1B2X.js";
+export { C as CacheHandler, D as DISPOSE, R as RecordArrayManager, B as Signals, S as Store, k as StoreMap, _ as _clearCaches, n as _deprecatingNormalize, h as assertPrivateCapabilities, d as assertPrivateStore, b as coerceId, c as constructResource, I as consumeInternalSignal, F as createInternalMemo, l as createLegacyManyArray, p as createRequestSubscription, z as defineGate, A as defineNonEnumerableSignal, y as defineSignal, e as ensureStringId, x as entangleInitiallyStaleSignal, w as entangleSignal, f as fastPush, v as gate, J as getOrCreateInternalSignal, q as getRequestState, g as isPrivateStore, a as isRequestKey, i as isResourceKey, m as log, o as logGroup, u as memoized, H as notifyInternalSignal, E as peekInternalSignal, r as recordIdentifierFor, j as setRecordIdentifier, t as signal, s as storeFor, G as withSignalStore } from "../index-D4si_DxB.js";
 export { A as ARRAY_SIGNAL, O as OBJECT_SIGNAL, w as waitFor } from "../configure-C3x8YXzL.js";

package/dist/types/-private.js

@@ -1,6 +1,6 @@
 import { macroCondition, getGlobalConfig } from '@embroider/macros';
 const name = "@warp-drive/core";
-const version = "5.8.0-alpha.30";
+const version = "5.8.0-alpha.34";
 
 // in testing mode, we utilize globals to ensure only one copy exists of
 // these maps, due to bugs in ember-auto-import

package/dist/unpkg/dev/build-config/babel-macros.js

@@ -0,0 +1 @@
+export { macros } from '@warp-drive/build-config/babel-macros';

package/dist/unpkg/dev/build-config/canary-features.js

@@ -0,0 +1 @@
+export * from '@warp-drive/build-config/canary-features';

package/dist/unpkg/dev/build-config/debugging.js

@@ -0,0 +1 @@
+export * from '@warp-drive/build-config/debugging';

package/dist/unpkg/dev/build-config/deprecations.js

@@ -0,0 +1 @@
+export * from '@warp-drive/build-config/deprecations';

package/dist/unpkg/dev/build-config/env.js

@@ -0,0 +1 @@
+export { DEBUG, IS_CI, IS_RECORDING, PRODUCTION, SHOULD_RECORD, TESTING } from '@warp-drive/build-config/env';

package/dist/unpkg/dev/build-config/macros.js

@@ -0,0 +1 @@
+export { assert } from '@warp-drive/build-config/macros';

package/dist/unpkg/dev/build-config.js

@@ -0,0 +1 @@
+export { babelPlugin, setConfig } from '@warp-drive/build-config';

package/dist/unpkg/dev/configure-C3x8YXzL.js

@@ -0,0 +1,181 @@
+import { getOrSetGlobal, peekTransient, setTransient } from './types/-private.js';
+import { macroCondition, getGlobalConfig } from '@embroider/macros';
+const ARRAY_SIGNAL = getOrSetGlobal('#[]', Symbol('#[]'));
+const OBJECT_SIGNAL = getOrSetGlobal('#{}', Symbol('#{}'));
+
+/**
+ * Requirements:
+ *
+ * Signal:
+ *
+ * - signal: a way of creating a reference that we can dirty when we desire to notify
+ *         - @signal: a way of creating an accessor on an object that subscribes to a signal on access
+ *                    and notifies the signal on set, or of upgrading a descriptor to be such an accessor
+ *         - defineSignal: a way of creating a signal on an object
+ *         - notifySignal: a way of notifying the underlying signal that it has been dirtied
+ *         - peekSignal: a way of inspecting the signal without notifying it
+ *
+ *  - gate: a memoized getter function that re-runs when on access if its signal is dirty
+ *          conceptually, a gate is a tightly coupled signal and memo
+ *         - @gate: a way of creating a gate on an object or upgrading a descriptor with a getter
+ *                  to be a gate
+ *         - defineGate: a way of creating a gate on an object
+ *         - notifySignal: a way of notifying the signal for a gate that it has been dirtied
+ *
+ * - memo:
+ *        - @memo: a way of creating a memoized getter on an object or upgrading a descriptor with a getter
+ *                 to be a memo
+ *        - defineMemo: a way of creating a memo on an object
+ *
+ * - signalStore: storage bucket for signals associated to an object
+ *        - withSignalStore: a way of pre-creating a signal store on an object
+ *
+ *
+ * @internal
+ */
+
+/**
+ * An Opaque type that represents a framework specific or TC39 signal.
+ *
+ * It may be an array of signals or a single signal.
+ *
+ * @private
+ */
+
+/**
+ * The hooks which MUST be configured in order to use reactive arrays,
+ * resources and documents with framework specfic signals or TC39 signals.
+ *
+ * Support for multiple frameworks simultaneously can be done via
+ * this abstraction by returning multiple signals from the `createSignal`
+ * method, and consuming the correct one via the correct framework via
+ * the `consumeSignal` and `notifySignal` methods.
+ *
+ * Unlike many signals implementations, WarpDrive does not wrap values as
+ * signals directly, but instead uses signals to alert the reactive layer
+ * to changes in the underlying cache. E.g. a signal is associated to a value,
+ * but does not serve as the cache for that value directly. We refer to this as
+ * a "gate", the pattern has also been called "side-signals".
+ *
+ * A no-op implementation is allowed, though it may lead to performance issues
+ * in locations that use createMemo as no memoization would be done. This is
+ * typically desirable only when integrating with a framework that does its own
+ * memoization and does not integrate with any signals-like primitive. For these
+ * scenarios you may also be interested in integrating with the {@link NotificationManager}
+ * more directly.
+ *
+ * @public
+ */
+
+/**
+ * Contains information a {@link SignalHooks} implementation may want
+ * to use, such as the specialized key used for the signal
+ * representing an array's contents / length.
+ *
+ * ```ts
+ * interface HooksOptions {
+ *   wellknown: {
+ *     Array: symbol | string;
+ *   }
+ * }
+ * ```
+ *
+ * @public
+ */
+
+/**
+ * Configures the signals implementation to use. Supports multiple
+ * implementations simultaneously.
+ *
+ * See {@link HooksOptions} for the options passed to the provided function
+ * when called.
+ *
+ * See {@link SignalHooks} for the implementation the callback function should
+ * return.
+ *
+ * @public
+ * @param buildConfig - a function that takes options and returns a configuration object
+ */
+function setupSignals(buildConfig) {
+  // We want to assert this but can't because too many package manager
+  // and bundler bugs exist that cause this to be called multiple times
+  // for what should be a single call.
+  // assert(`Cannot override configured signal hooks`, peekTransient('signalHooks') === null);
+  const hooks = buildConfig({
+    wellknown: {
+      Array: ARRAY_SIGNAL
+    }
+  });
+  setTransient('signalHooks', hooks);
+}
+
+/**
+ * Internal method for consuming the configured `createSignal` hook
+ *
+ * @private
+ */
+function createSignal(obj, key) {
+  const signalHooks = peekTransient('signalHooks');
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`Signal hooks not configured`);
+    }
+  })(signalHooks) : {};
+  return signalHooks.createSignal(obj, key);
+}
+
+/**
+ * Internal method for consuming the configured `consumeSignal` hook
+ *
+ * @private
+ */
+function consumeSignal(signal) {
+  const signalHooks = peekTransient('signalHooks');
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`Signal hooks not configured`);
+    }
+  })(signalHooks) : {};
+  return signalHooks.consumeSignal(signal);
+}
+
+/**
+ * Internal method for consuming the configured `notifySignal` hook
+ *
+ * @private
+ */
+function notifySignal(signal) {
+  const signalHooks = peekTransient('signalHooks');
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`Signal hooks not configured`);
+    }
+  })(signalHooks) : {};
+  return signalHooks.notifySignal(signal);
+}
+function createMemo(object, key, fn) {
+  const signalHooks = peekTransient('signalHooks');
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`Signal hooks not configured`);
+    }
+  })(signalHooks) : {};
+  return signalHooks.createMemo(object, key, fn);
+}
+function willSyncFlushWatchers() {
+  const signalHooks = peekTransient('signalHooks');
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`Signal hooks not configured`);
+    }
+  })(signalHooks) : {};
+  return signalHooks.willSyncFlushWatchers();
+}
+function waitFor(promise) {
+  const signalHooks = peekTransient('signalHooks');
+  if (signalHooks?.waitFor) {
+    return signalHooks.waitFor(promise);
+  }
+  return promise;
+}
+export { ARRAY_SIGNAL as A, OBJECT_SIGNAL as O, consumeSignal as a, createMemo as b, createSignal as c, willSyncFlushWatchers as d, notifySignal as n, setupSignals as s, waitFor as w };

package/dist/unpkg/dev/configure.js

@@ -0,0 +1 @@
+export { s as setupSignals } from "./configure-C3x8YXzL.js";

package/dist/unpkg/dev/declarations/build-config/babel-macros.d.ts

@@ -0,0 +1 @@
+export { macros } from "@warp-drive/build-config/babel-macros";

package/dist/unpkg/dev/declarations/build-config/canary-features.d.ts

@@ -0,0 +1 @@
+export * from "@warp-drive/build-config/canary-features";

package/dist/unpkg/dev/declarations/build-config/debugging.d.ts

@@ -0,0 +1 @@
+export * from "@warp-drive/build-config/debugging";

package/dist/unpkg/dev/declarations/build-config/deprecations.d.ts

@@ -0,0 +1 @@
+export * from "@warp-drive/build-config/deprecations";

package/dist/unpkg/dev/declarations/build-config/env.d.ts

@@ -0,0 +1 @@
+export { DEBUG, PRODUCTION, IS_CI, IS_RECORDING, SHOULD_RECORD, TESTING } from "@warp-drive/build-config/env";

package/dist/unpkg/dev/declarations/build-config/macros.d.ts

@@ -0,0 +1 @@
+export { assert } from "@warp-drive/build-config/macros";

package/dist/unpkg/dev/declarations/build-config.d.ts

@@ -0,0 +1,18 @@
+/**
+* This module provides a build-plugin that enables configuration of deprecations,
+* optional features, development/testing support and debug logging.
+*
+* Available settings include:
+*
+* - {@link LOGGING | debugging}
+* - {@link DEPRECATIONS | deprecations}
+* - {@link FEATURES | features}
+* - {@link WarpDriveConfig.polyfillUUID | polyfillUUID}
+* - {@link WarpDriveConfig.includeDataAdapterInProduction | includeDataAdapterInProduction}
+* - {@link WarpDriveConfig.compatWith | compatWith}
+*
+* @module
+*/
+import type { WarpDriveConfig } from "@warp-drive/build-config";
+export { setConfig, babelPlugin } from "@warp-drive/build-config";
+export type { WarpDriveConfig };

package/dist/unpkg/dev/declarations/configure.d.ts

@@ -0,0 +1,7 @@
+/**
+* Provides a configuration API for the reactivity system
+* that WarpDrive should use.
+*
+* @module
+*/
+export { setupSignals, type HooksOptions, type SignalHooks } from "./store/-private/new-core-tmp/reactivity/configure.js";

package/dist/unpkg/dev/declarations/graph/-private/-diff.d.ts

@@ -0,0 +1,19 @@
+import type { ResourceKey } from "../../types/identifier.js";
+import type { CollectionEdge } from "./edges/collection.js";
+import type { ResourceEdge } from "./edges/resource.js";
+import type { Graph } from "./graph.js";
+type Diff<T> = {
+	add: Set<T>;
+	del: Set<T>;
+	finalState: T[];
+	finalSet: Set<T>;
+	changed: boolean;
+	remoteOrderChanged: boolean;
+};
+export declare function diffCollection(finalState: ResourceKey[], relationship: CollectionEdge, onAdd: (v: ResourceKey) => void, onDel: (v: ResourceKey) => void): Diff<ResourceKey>;
+export declare function computeLocalState(storage: CollectionEdge): ResourceKey[];
+export declare function _remove(graph: Graph, record: ResourceKey, relationship: CollectionEdge, value: ResourceKey, index: number | null, isRemote: boolean): boolean;
+export declare function _removeLocal(relationship: CollectionEdge, value: ResourceKey): boolean;
+export declare function _removeRemote(relationship: CollectionEdge, value: ResourceKey): boolean;
+export declare function rollbackRelationship(graph: Graph, key: ResourceKey, field: string, relationship: CollectionEdge | ResourceEdge): void;
+export {};

package/dist/unpkg/dev/declarations/graph/-private/-edge-definition.d.ts

@@ -0,0 +1,149 @@
+import type { ResourceKey } from "../../types.js";
+import type { CollectionField, FieldSchema, LegacyBelongsToField, LegacyHasManyField, ResourceField } from "../../types/schema/fields.js";
+import type { Graph } from "./graph.js";
+export type EdgeCache = Record<string, Record<string, EdgeDefinition | null>>;
+export type RelationshipField = LegacyBelongsToField | LegacyHasManyField | ResourceField | CollectionField;
+export type RelationshipFieldKind = RelationshipField["kind"];
+export type CollectionKind = "hasMany" | "collection";
+export type ResourceKind = "belongsTo" | "resource";
+export declare const RELATIONSHIP_KINDS: string[];
+export declare function isLegacyField(field: FieldSchema): field is LegacyBelongsToField | LegacyHasManyField;
+export declare function isRelationshipField(field: FieldSchema): field is RelationshipField;
+export declare function temporaryConvertToLegacy(field: ResourceField | CollectionField): LegacyBelongsToField | LegacyHasManyField;
+/**
+*
+* Given RHS (Right Hand Side)
+*
+* ```ts
+* class User extends Model {
+*   @hasMany('animal', { async: false, inverse: 'owner' }) pets;
+* }
+* ```
+*
+* Given LHS (Left Hand Side)
+*
+* ```ts
+* class Animal extends Model {
+*  @belongsTo('user', { async: false, inverse: 'pets' }) owner;
+* }
+* ```
+*
+* The UpgradedMeta for the RHS would be:
+*
+* ```ts
+* {
+*   kind: 'hasMany',
+*   key: 'pets',
+*   type: 'animal',
+*   isAsync: false,
+*   isImplicit: false,
+*   isCollection: true,
+*   isPolymorphic: false,
+*   inverseKind: 'belongsTo',
+*   inverseKey: 'owner',
+*   inverseType: 'user',
+*   inverseIsAsync: false,
+*   inverseIsImplicit: false,
+*   inverseIsCollection: false,
+*   inverseIsPolymorphic: false,
+* }
+* ```
+*
+* The UpgradeMeta for the LHS would be:
+*
+* ```ts
+* {
+*   kind: 'belongsTo',
+*   key: 'owner',
+*   type: 'user',
+*   isAsync: false,
+*   isImplicit: false,
+*   isCollection: false,
+*   isPolymorphic: false,
+*   inverseKind: 'hasMany',
+*   inverseKey: 'pets',
+*   inverseType: 'animal',
+*   inverseIsAsync: false,
+*   inverseIsImplicit: false,
+*   inverseIsCollection: true,
+*   inverseIsPolymorphic: false,
+* }
+* ```
+*
+* @private
+*/
+export interface UpgradedMeta {
+	kind: "implicit" | RelationshipFieldKind;
+	/**
+	* The field sourceKey on `this` record,
+	* name if sourceKey is not set.
+	*/
+	key: string;
+	/**
+	* The field name on `this` record
+	*/
+	name: string;
+	/**
+	* The `type` of the related record
+	*
+	*/
+	type: string;
+	isAsync: boolean;
+	isImplicit: boolean;
+	isCollection: boolean;
+	isPolymorphic: boolean;
+	resetOnRemoteUpdate: boolean;
+	isLinksMode: boolean;
+	inverseKind: "implicit" | RelationshipFieldKind;
+	/**
+	* The field sourceKey on the opposing record,
+	* name if sourceKey is not set.
+	*/
+	inverseKey: string;
+	/**
+	* The field name on the opposing record,
+	*/
+	inverseName: string;
+	/**
+	* The `type` of `this` record
+	*/
+	inverseType: string;
+	inverseIsAsync: boolean;
+	inverseIsImplicit: boolean;
+	inverseIsCollection: boolean;
+	inverseIsPolymorphic: boolean;
+	inverseIsLinksMode: boolean;
+}
+export interface EdgeDefinition {
+	lhs_key: string;
+	lhs_modelNames: string[];
+	lhs_baseModelName: string;
+	lhs_relationshipName: string;
+	lhs_definition: UpgradedMeta;
+	lhs_isPolymorphic: boolean;
+	rhs_key: string;
+	rhs_modelNames: string[];
+	rhs_baseModelName: string;
+	rhs_relationshipName: string;
+	rhs_definition: UpgradedMeta | null;
+	rhs_isPolymorphic: boolean;
+	hasInverse: boolean;
+	/**
+	* Whether this relationship points back at the same type.
+	*
+	* If the relationship is polymorphic, this will be true if
+	* it points back at the same abstract type.
+	*
+	*/
+	isSelfReferential: boolean;
+	/**
+	* If this is a reflexive relationship, this is true
+	* if the relationship also points back at the same
+	* field.
+	*
+	*/
+	isReflexive: boolean;
+}
+export declare function isLHS(info: EdgeDefinition, type: string, key: string): boolean;
+export declare function isRHS(info: EdgeDefinition, type: string, key: string): boolean;
+export declare function upgradeDefinition(graph: Graph, key: ResourceKey, propertyName: string, isImplicit?: boolean): EdgeDefinition | null;