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

package/dist/graph-DLqYXP2z.d.ts

@@ -0,0 +1,186 @@
+import { l as ResourceKey } from "./identifier-DQnqOSJK.js";
+import { b as SingleResourceRelationship, n as CollectionResourceRelationship } from "./json-api-raw-C5APJHHB.js";
+import { r as RemoveFromResourceRelationshipMutation, t as AddToResourceRelationshipMutation } from "./mutations-CqtoGB4t.js";
+import { l as RemoveFromResourceRelationshipOperation, p as UpdateResourceRelationshipOperation, r as AddToResourceRelationshipOperation } from "./operations-D1qA6r0_.js";
+//#region src/types/graph.d.ts
+/**
+ * All Graph operations are objects with at least one property,
+ * `op`, which contains a string with the name of the operation
+ * to perform.
+ */
+interface Operation {
+  /**
+   * The name of the {@link Operation | operation}
+   */
+  op: string;
+}
+/**
+ * Replaces the state of a relationship on the Graph with a new state.
+ */
+interface UpdateRelationshipOperation {
+  /**
+   * The name of the operation
+   */
+  op: "updateRelationship";
+  /**
+   * The cache key for the resource whose relationship is being updated
+   */
+  record: ResourceKey;
+  /**
+   * The name of the relationship to update
+   */
+  field: string;
+  /**
+   * The new state for the relationship
+   */
+  value: SingleResourceRelationship | CollectionResourceRelationship;
+}
+/**
+ * Signals to the Graph that a resource has been deleted, so that
+ * it can be removed from any relationships that reference it.
+ */
+interface DeleteRecordOperation {
+  /**
+   * The name of the operation
+   */
+  op: "deleteRecord";
+  /**
+   * The cache key for the resource that was deleted
+   */
+  record: ResourceKey;
+  /**
+   * Whether the resource was a client-created resource that had not yet been persisted
+   */
+  isNew: boolean;
+}
+/**
+ * A placeholder operation for a relationship whose kind (`to-one` vs
+ * `to-many`) is not yet known to the Graph.
+ */
+interface UnknownOperation {
+  /**
+   * The name of the operation
+   */
+  op: "never";
+  /**
+   * The cache key for the resource whose relationship is affected
+   */
+  record: ResourceKey;
+  /**
+   * The name of the relationship
+   */
+  field: string;
+}
+/**
+ * Replaces the state of a `to-one` relationship on the Graph with a new value.
+ */
+interface ReplaceRelatedRecordOperation {
+  /**
+   * The name of the operation
+   */
+  op: "replaceRelatedRecord";
+  /**
+   * The cache key for the resource whose relationship is being updated
+   */
+  record: ResourceKey;
+  /**
+   * The name of the relationship to replace
+   */
+  field: string;
+  /**
+   * The new value for the relationship. Never `null` if the field is
+   * actually a collection relationship.
+   */
+  value: ResourceKey | null;
+  /**
+   * If the field is a collection relationship, the value being swapped out
+   */
+  prior?: ResourceKey;
+  /**
+   * If the field is a collection relationship, the index at which the swap occurred
+   */
+  index?: number;
+}
+/**
+ * Reorders the state of a `to-many` relationship on the Graph.
+ */
+interface SortRelatedRecords {
+  /**
+   * The name of the operation
+   */
+  op: "sortRelatedRecords";
+  /**
+   * The cache key for the resource whose relationship is being reordered
+   */
+  record: ResourceKey;
+  /**
+   * The name of the relationship to reorder
+   */
+  field: string;
+  /**
+   * The relationship's members in their new order
+   */
+  value: ResourceKey[];
+}
+/**
+ * Replaces the state of a `to-many` relationship on the Graph with a
+ * new set of values.
+ */
+interface ReplaceRelatedRecordsOperation {
+  /**
+   * The name of the operation
+   */
+  op: "replaceRelatedRecords";
+  /**
+   * The cache key for the resource whose relationship is being updated
+   */
+  record: ResourceKey;
+  /**
+   * The name of the relationship to replace
+   */
+  field: string;
+  /**
+   * The resources to add. If neither {@link ReplaceRelatedRecordsOperation.prior | prior}
+   * nor {@link ReplaceRelatedRecordsOperation.index | index} is specified, all
+   * existing members should be removed.
+   */
+  value: ResourceKey[];
+  /**
+   * If this is a "splice", the resources expected to be removed
+   */
+  prior?: ResourceKey[];
+  /**
+   * If this is a "splice", the index to start from
+   */
+  index?: number;
+}
+/**
+ * The Graph operations that apply to a relationship's remote
+ * (persisted/clean) state.
+ *
+ * See also:
+ * - {@link UpdateResourceRelationshipOperation}
+ * - {@link UpdateRelationshipOperation}
+ * - {@link ReplaceRelatedRecordOperation}
+ * - {@link ReplaceRelatedRecordsOperation}
+ * - {@link RemoveResourceOperation}
+ * - {@link AddResourceOperation}
+ * - {@link DeleteRecordOperation}
+ * - {@link SortRelatedRecords}
+ */
+type RemoteRelationshipOperation = UpdateResourceRelationshipOperation | UpdateRelationshipOperation | ReplaceRelatedRecordOperation | ReplaceRelatedRecordsOperation | RemoveFromResourceRelationshipOperation | AddToResourceRelationshipOperation | DeleteRecordOperation | SortRelatedRecords;
+/**
+ * The Graph operations that apply to a relationship's local
+ * (uncommitted/dirty) state.
+ *
+ * See also:
+ * - {@link ReplaceRelatedRecordsOperation}
+ * - {@link ReplaceRelatedRecordOperation}
+ * - {@link AddResourceMutation}
+ * - {@link RemoveResourceMutation}
+ * - {@link SortRelatedRecords}
+ */
+type LocalRelationshipOperation = ReplaceRelatedRecordsOperation | ReplaceRelatedRecordOperation | AddToResourceRelationshipMutation | RemoveFromResourceRelationshipMutation | SortRelatedRecords;
+//#endregion
+export { ReplaceRelatedRecordOperation as a, UnknownOperation as c, RemoteRelationshipOperation as i, UpdateRelationshipOperation as l, LocalRelationshipOperation as n, ReplaceRelatedRecordsOperation as o, Operation as r, SortRelatedRecords as s, DeleteRecordOperation as t };
+//# sourceMappingURL=graph-DLqYXP2z.d.ts.map

package/dist/graph-DLqYXP2z.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph-DLqYXP2z.d.ts","names":[],"sources":["../src/types/graph.ts"],"mappings":";;;;;;;;;;UAiBiB;;;;EAIf;;;;;UAMe;;;;EAIf;;;;EAIA,QAAQ;;;;EAIR;;;;EAIA,OAAO,6BAA6B;;;;;;UAOrB;;;;EAIf;;;;EAIA,QAAQ;;;;EAIR;;;;;;UAOe;;;;EAIf;;;;EAIA,QAAQ;;;;EAIR;;;;;UAMe;;;;EAIf;;;;EAIA,QAAQ;;;;EAIR;;;;;EAKA,OAAO;;;;EAIP,QAAQ;;;;EAIR;;;;;UAMe;;;;EAIf;;;;EAIA,QAAQ;;;;EAIR;;;;EAIA,OAAO;;;;;;UAOQ;;;;EAIf;;;;EAIA,QAAQ;;;;EAIR;;;;;;EAMA,OAAO;;;;EAIP,QAAQ;;;;EAIR;;;;;;;;;;;;;;;;KAiBU,8BACR,sCACA,8BACA,gCACA,iCACA,0CACA,qCACA,wBACA;;;;;;;;;;;;KAaQ,6BACR,iCACA,gCACA,oCACA,yCACA"}

package/dist/identifier-DQnqOSJK.d.ts

@@ -0,0 +1,112 @@
+//#region src/types/identifier.d.ts
+/**
+ * @private
+ */
+declare const DEBUG_CLIENT_ORIGINATED: unique symbol;
+/**
+ * @private
+ */
+declare const DEBUG_KEY_TYPE: unique symbol;
+/**
+ * @private
+ */
+declare const DEBUG_STALE_CACHE_OWNER: unique symbol;
+/**
+ * @private
+ */
+declare const CACHE_OWNER: "__$co";
+/**
+ * Identifies which "bucket" of the cache a key belongs to: resources
+ * (`'record'`, see {@link ResourceKey}) or request documents
+ * (`'document'`, see {@link RequestKey}).
+ */
+type CacheKeyType = "record" | "document";
+/**
+ * A referentially stable object with a unique string (lid) that can be used
+ * as a reference to request data in the cache.
+ *
+ * Only requests that are assigned a RequestKey are retrievable/replayable from
+ * the cache, though requests without RequestKeys may still update cache state.
+ *
+ * @public
+ */
+interface RequestKey {
+  /**
+   * A string representing a unique identity.
+   */
+  lid: string;
+  /**
+   * Discriminates a {@link RequestKey} from a {@link ResourceKey}.
+   */
+  type: "@document";
+}
+/** @deprecated use {@link RequestKey} */
+type StableDocumentIdentifier = RequestKey;
+/**
+ * Used when an ResourceKey is known to be the stable version
+ */
+interface ResourceKeyBase<T extends string = string> {
+  /**
+   * A string representing a unique identity.
+   *
+   * @public
+   */
+  lid: string;
+  /**
+   * the primary `ResourceType` or "model name" this ResourceKey belongs to.
+   *
+   * @public
+   */
+  type: T;
+}
+/**
+ * Used when a ResourceKey was not created locally as part
+ * of a call to store.createRecord
+ *
+ * Distinguishing between this ResourceKey and one for a client created
+ * resource that was created with an ID is generally speaking not possible
+ * at runtime, so anything with an ID typically narrows to this.
+ */
+interface PersistedResourceKey<T extends string = string> extends ResourceKeyBase<T> {
+  /**
+   * the PrimaryKey for the resource this ResourceKey represents.
+   *
+   * @public
+   */
+  id: string;
+}
+/** @deprecated use {@link PersistedResourceKey} */
+type StableExistingRecordIdentifier<T extends string = string> = PersistedResourceKey<T>;
+/**
+ * Used when a ResourceKey was created locally
+ * (by a call to store.createRecord).
+ *
+ * It is possible in rare circumstances to have a ResourceKey
+ * that is not for a new record but does not have an ID. This would
+ * happen if a user intentionally created one for use with a secondary-index
+ * prior to the record having been fully loaded.
+ */
+interface NewResourceKey<T extends string = string> extends ResourceKeyBase<T> {
+  /**
+   * the PrimaryKey for the resource this ResourceKey represents. `null`
+   * if not yet assigned a PrimaryKey value.
+   *
+   * @public
+   */
+  id: string | null;
+}
+/**
+ * A referentially stable object with a unique string (lid) that can be used
+ * as a reference to data in the cache.
+ *
+ * Every resource has a unique ResourceKey, and ResourceKeys may refer
+ * to data that has never been loaded (for instance, in an async relationship).
+ *
+ * @public
+ */
+type ResourceKey<T extends string = string> = PersistedResourceKey<T> | NewResourceKey<T>;
+/** @deprecated use {@link ResourceKey} */
+type StableRecordIdentifier<T extends string = string> = ResourceKey<T>;
+//#endregion
+export { DEBUG_STALE_CACHE_OWNER as a, RequestKey as c, StableExistingRecordIdentifier as d, StableRecordIdentifier as f, DEBUG_KEY_TYPE as i, ResourceKey as l, CacheKeyType as n, NewResourceKey as o, DEBUG_CLIENT_ORIGINATED as r, PersistedResourceKey as s, CACHE_OWNER as t, StableDocumentIdentifier as u };
+//# sourceMappingURL=identifier-DQnqOSJK.d.ts.map

package/dist/identifier-DQnqOSJK.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"identifier-DQnqOSJK.d.ts","names":[],"sources":["../src/types/identifier.ts"],"mappings":";;;;cAMa;;;;cAIA;;;;cAIA;;;;cAUA;;;;;;KAOD;;;;;;;;;;UAWK;;;;EAIf;;;;EAIA;;;KAMU,2BAA2B;;;;UAK7B,gBAAgB;;;;;;EAMxB;;;;;;EAOA,MAAM;;;;;;;;;;UAmBS,qBAAqB,mCAAmC,gBAAgB;;;;;;EAMvF;;;KAIU,+BAA+B,6BAA6B,qBAAqB;;;;;;;;;;UAW5E,eAAe,mCAAmC,gBAAgB;;;;;;;EAOjF;;;;;;;;;;;KAYU,YAAY,6BAA6B,qBAAqB,KAAK,eAAe;;KAGlF,uBAAuB,6BAA6B,YAAY"}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import { Cn as setIdentifierResetMethod, D as useRecommendedStore, Dt as StoreRequestContext, E as StoreSetupOptions, Et as CacheHandler, M as Fetch, Ot as StoreRequestInput, Sn as setIdentifierGenerationMethod, T as Document, Tn as setKeyInfoForResource, Tt as CachePolicy, Y as Store, _n as NotificationType, _t as recordIdentifierFor, hn as NotificationChannel, mn as DocumentCacheOperation, or as RequestManager, pn as CacheOperation, vn as NotifyKeys, w as ConfiguredStore, wn as setIdentifierUpdateMethod, xn as setIdentifierForgetMethod, yt as storeFor } from "./internal-DtWOpxrR.js";
+export { CacheHandler, type CacheOperation, type CachePolicy, ConfiguredStore, Document, type DocumentCacheOperation, Fetch, type NotificationChannel, type NotificationType, type NotifyKeys, RequestManager, Store, type StoreRequestContext, type StoreRequestInput, StoreSetupOptions, recordIdentifierFor as cacheKeyFor, recordIdentifierFor, setIdentifierForgetMethod, setIdentifierGenerationMethod, setIdentifierResetMethod, setIdentifierUpdateMethod, setKeyInfoForResource, storeFor, useRecommendedStore };

package/dist/index.js

@@ -1,8 +1,3 @@
-export { C as CacheHandler, F as Fetch, z as RequestManager, S as Store, r as cacheKeyFor, r as recordIdentifierFor, E as setIdentifierForgetMethod, B as setIdentifierGenerationMethod, G as setIdentifierResetMethod, D as setIdentifierUpdateMethod, H as setKeyInfoForResource, s as storeFor, A as useRecommendedStore } from "./index-CQP2NSqg.js";
-import "./symbols-3C1OkYtZ.js";
-import "./configure-DPUFCemT.js";
-import '@embroider/macros';
-import "./default-cache-policy-D7_u4YRH.js";
-import '@ember/debug';
-import './utils/string.js';
-import './types/runtime.js';
+import { A as setIdentifierResetMethod, M as setKeyInfoForResource, O as setIdentifierForgetMethod, S as recordIdentifierFor, h as Store, j as setIdentifierUpdateMethod, k as setIdentifierGenerationMethod, m as CacheHandler, n as RequestManager, r as Fetch, t as useRecommendedStore, w as storeFor } from "./src-BOAWJH_S.js";
+
+export { CacheHandler, Fetch, RequestManager, Store, recordIdentifierFor as cacheKeyFor, recordIdentifierFor, setIdentifierForgetMethod, setIdentifierGenerationMethod, setIdentifierResetMethod, setIdentifierUpdateMethod, setKeyInfoForResource, storeFor, useRecommendedStore };