@warp-drive/core 5.6.0-alpha.11

package/declarations/store/-private/default-cache-policy.d.ts

@@ -0,0 +1,383 @@
+import type { Cache } from '@warp-drive/core/types/cache';
+import type { StableDocumentIdentifier, StableRecordIdentifier } from '@warp-drive/core/types/identifier';
+import type { ImmutableRequestInfo, ResponseInfo, StructuredDocument } from '@warp-drive/core/types/request';
+import type { ResourceDocument } from '@warp-drive/core/types/spec/document';
+type UnsubscribeToken = object;
+type CacheOperation = 'added' | 'removed' | 'updated' | 'state';
+type DocumentCacheOperation = 'invalidated' | 'added' | 'removed' | 'updated' | 'state';
+export interface NotificationCallback {
+    (identifier: StableRecordIdentifier, notificationType: 'attributes' | 'relationships', key?: string): void;
+    (identifier: StableRecordIdentifier, notificationType: 'errors' | 'meta' | 'identity' | 'state'): void;
+}
+interface ResourceOperationCallback {
+    (identifier: StableRecordIdentifier, notificationType: CacheOperation): void;
+}
+interface DocumentOperationCallback {
+    (identifier: StableDocumentIdentifier, notificationType: DocumentCacheOperation): void;
+}
+type NotificationManager = {
+    subscribe(identifier: StableRecordIdentifier, callback: NotificationCallback): UnsubscribeToken;
+    subscribe(identifier: 'resource', callback: ResourceOperationCallback): UnsubscribeToken;
+    subscribe(identifier: 'document' | StableDocumentIdentifier, callback: DocumentOperationCallback): UnsubscribeToken;
+    notify(identifier: StableRecordIdentifier, value: 'attributes' | 'relationships', key?: string): boolean;
+    notify(identifier: StableRecordIdentifier, value: 'errors' | 'meta' | 'identity' | 'state'): boolean;
+    notify(identifier: StableRecordIdentifier, value: CacheOperation): boolean;
+    notify(identifier: StableDocumentIdentifier, value: DocumentCacheOperation): boolean;
+};
+type Store = {
+    cache: Cache;
+    notifications: NotificationManager;
+};
+export interface CacheControlValue {
+    immutable?: boolean;
+    'max-age'?: number;
+    'must-revalidate'?: boolean;
+    'must-understand'?: boolean;
+    'no-cache'?: boolean;
+    'no-store'?: boolean;
+    'no-transform'?: boolean;
+    'only-if-cached'?: boolean;
+    private?: boolean;
+    'proxy-revalidate'?: boolean;
+    public?: boolean;
+    's-maxage'?: number;
+    'stale-if-error'?: number;
+    'stale-while-revalidate'?: number;
+}
+/**
+ *  Parses a string Cache-Control header value into an object with the following structure:
+ *
+ * ```ts
+ * interface CacheControlValue {
+ *   immutable?: boolean;
+ *   'max-age'?: number;
+ *   'must-revalidate'?: boolean;
+ *   'must-understand'?: boolean;
+ *   'no-cache'?: boolean;
+ *   'no-store'?: boolean;
+ *   'no-transform'?: boolean;
+ *   'only-if-cached'?: boolean;
+ *   private?: boolean;
+ *   'proxy-revalidate'?: boolean;
+ *   public?: boolean;
+ *   's-maxage'?: number;
+ *   'stale-if-error'?: number;
+ *   'stale-while-revalidate'?: number;
+ * }
+ * ```
+ *
+ * @public
+ * @param {String} header
+ * @return {CacheControlValue}
+ */
+export declare function parseCacheControl(header: string): CacheControlValue;
+/**
+ * The configuration options for the {@link DefaultCachePolicy}
+ *
+ * ```ts
+ * import { DefaultCachePolicy } from '@warp-drive/core/store';
+ *
+ * new DefaultCachePolicy({
+ *   // ... PolicyConfig Settings ... //
+ * });
+ * ```
+ *
+ */
+export type PolicyConfig = {
+    /**
+     * the number of milliseconds after which a request is considered
+     * stale. If a request is issued again after this time, the request
+     * will respond from cache immediately while a background request
+     * is made to update the cache.
+     *
+     * This is calculated against the `date` header of the response.
+     *
+     * If your API does not provide a `date` header, the `Fetch` handler
+     * provided by `@warp-drive/core` will automatically add
+     * it to responses if it is not present. Responses without a `date`
+     * header will be considered stale immediately.
+     *
+     */
+    apiCacheSoftExpires: number;
+    /**
+     * the number of milliseconds after which a request is considered
+     * expired and should be re-fetched. If a request is issued again
+     * after this time, the request will disregard the cache and
+     * wait for a fresh response from the API.
+     *
+     * This is calculated against the `date` header of the response.
+     *
+     * If your API does not provide a `date` header, the `Fetch` handler
+     * provided by `@warp-drive/core` will automatically add
+     * it to responses if it is not present. Responses without a `date`
+     * header will be considered hard expired immediately.
+     *
+     */
+    apiCacheHardExpires: number;
+    /**
+     * In Testing environments, the `apiCacheSoftExpires` will always be `false`
+     * and `apiCacheHardExpires` will use the `apiCacheSoftExpires` value.
+     *
+     * This helps reduce flakiness and produce predictably rendered results in test suites.
+     *
+     * Requests that specifically set `cacheOptions.backgroundReload = true` will
+     * still be background reloaded in tests.
+     *
+     * This behavior can be opted out of by setting this value to `true`.
+     *
+     */
+    disableTestOptimization?: boolean;
+    /**
+     * In addition to the simple time-based expiration strategy, CachePolicy
+     * supports various common server-supplied expiration strategies via
+     * headers, as well as custom expiration strategies via the `isExpired`
+     * function.
+     *
+     * Requests will be validated for expiration against these constraints.
+     * If any of these constraints are not met, the request will be considered
+     * expired. If all constraints are met, the request will be considered
+     * valid and the time based expiration strategy will NOT be used.
+     *
+     * Meeting a constraint means BOTH that the properties the constraint
+     * requires are present AND that the expiration time indicated by those
+     * properties has not been exceeded.
+     *
+     * In other words, if the properties for a constraint are not present,
+     * this does not count either as meeting or as not meeting the constraint,
+     * the constraint simply does not apply.
+     *
+     * The `isExpired` function is called with the request and should return
+     * `true` if the request is expired, `false` if it is not expired, and
+     * `null` if the expiration status is unknown.
+     *
+     * In order constraints are checked:
+     *
+     * - isExpired function
+     * -  ↳ (if null) X-WarpDrive-Expires header
+     * -  ↳ (if null) Cache-Control header
+     * -  ↳ (if null) Expires header
+     *
+     */
+    constraints?: {
+        /**
+         * Headers that should be checked for expiration.
+         *
+         */
+        headers?: {
+            /**
+             * Whether the `Cache-Control` header should be checked for expiration.
+             * If `true`, then the `max-age` and `s-maxage` directives are used alongside
+             * the `Age` and `Date` headers to determine if the expiration time has passed.
+             *
+             * Other directives are ignored.
+             *
+             * 'Cache-Control' will take precedence over 'Expires' if both are present
+             * and both configured to be checked.
+             *
+             */
+            'Cache-Control'?: boolean;
+            /**
+             * Whether the `Expires` header should be checked for expiration.
+             *
+             * If `true`, then the `Expires` header is used to caclulate the expiration time
+             * and determine if the expiration time has passed.
+             *
+             * 'Cache-Control' will take precedence over 'Expires' if both are present.
+             *
+             */
+            Expires?: boolean;
+            /**
+             * Whether the `X-WarpDrive-Expires` header should be checked for expiration.
+             *
+             * If `true`, then the `X-WarpDrive-Expires` header is used to caclulate the expiration time
+             * and determine if the expiration time has passed.
+             *
+             * This header will take precedence over 'Cache-Control' and 'Expires' if all three are present.
+             *
+             * The header's value should be a [UTC date string](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toUTCString).
+             *
+             */
+            'X-WarpDrive-Expires'?: boolean;
+        };
+        /**
+         * A function that should be called to determine if the request is expired.
+         *
+         * If present, this function will be called with the request and should return
+         * `true` if the request is expired, `false` if it is not expired, and
+         * `null` if the expiration status is unknown.
+         *
+         * If the function does not return `null`,
+         *
+         */
+        isExpired?: (request: StructuredDocument<ResourceDocument>) => boolean | null;
+    };
+};
+/**
+ * A basic CachePolicy that can be added to the Store service.
+ *
+ * Determines staleness based on time since the request was last received from the API
+ * using the `date` header.
+ *
+ * Determines expiration based on configured constraints as well as a time based
+ * expiration strategy based on the `date` header.
+ *
+ * In order expiration is determined by:
+ *
+ * - Is explicitly invalidated
+ * -  ↳ (if null) isExpired function \<IF Constraint Active>
+ * -  ↳ (if null) X-WarpDrive-Expires header \<IF Constraint Active>
+ * -  ↳ (if null) Cache-Control header \<IF Constraint Active>
+ * -  ↳ (if null) Expires header \<IF Constraint Active>
+ * -  ↳ (if null) Date header + apiCacheHardExpires \< current time
+ *
+ * Invalidates any request for which `cacheOptions.types` was provided when a createRecord
+ * request for that type is successful.
+ *
+ * For this to work, the `createRecord` request must include the `cacheOptions.types` array
+ * with the types that should be invalidated, or its request should specify the identifiers
+ * of the records that are being created via `records`. Providing both is valid.
+ *
+ * > [!NOTE]
+ * > only requests that had specified `cacheOptions.types` and occurred prior to the
+ * > createRecord request will be invalidated. This means that a given request should always
+ * > specify the types that would invalidate it to opt into this behavior. Abstracting this
+ * > behavior via builders is recommended to ensure consistency.
+ *
+ * This allows the Store's CacheHandler to determine if a request is expired and
+ * should be refetched upon next request.
+ *
+ * The `Fetch` handler provided by `@warp-drive/core` will automatically
+ * add the `date` header to responses if it is not present.
+ *
+ * > [!NOTE]
+ * > Date headers do not have millisecond precision, so expiration times should
+ * > generally be larger than 1000ms.
+ *
+ * Usage:
+ *
+ * ```ts
+ * import { Store } from '@warp-drive/core';
+ * import { DefaultCachePolicy } from '@warp-drive/core/store';
+ *
+ * export class AppStore extends Store {
+ *   lifetimes = new DefaultCachePolicy({
+ *     apiCacheSoftExpires: 30_000,
+ *     apiCacheHardExpires: 60_000
+ *   });
+ * }
+ * ```
+ *
+ * In Testing environments, the `apiCacheSoftExpires` will always be `false`
+ * and `apiCacheHardExpires` will use the `apiCacheSoftExpires` value.
+ *
+ * This helps reduce flakiness and produce predictably rendered results in test suites.
+ *
+ * Requests that specifically set `cacheOptions.backgroundReload = true` will
+ * still be background reloaded in tests.
+ *
+ * This behavior can be opted out of by setting `disableTestOptimization = true`
+ * in the policy config.
+ *
+ * @public
+ */
+export declare class DefaultCachePolicy {
+    config: PolicyConfig;
+    _stores: WeakMap<Store, {
+        invalidated: Set<StableDocumentIdentifier>;
+        types: Map<string, Set<StableDocumentIdentifier>>;
+    }>;
+    _getStore(store: Store): {
+        invalidated: Set<StableDocumentIdentifier>;
+        types: Map<string, Set<StableDocumentIdentifier>>;
+    };
+    constructor(config: PolicyConfig);
+    /**
+     * Invalidate a request by its identifier for a given store instance.
+     *
+     * While the store argument may seem redundant, the CachePolicy
+     * is designed to be shared across multiple stores / forks
+     * of the store.
+     *
+     * ```ts
+     * store.lifetimes.invalidateRequest(store, identifier);
+     * ```
+     *
+     * @public
+     * @param {StableDocumentIdentifier} identifier
+     * @param {Store} store
+     */
+    invalidateRequest(identifier: StableDocumentIdentifier, store: Store): void;
+    /**
+     * Invalidate all requests associated to a specific type
+     * for a given store instance.
+     *
+     * While the store argument may seem redundant, the CachePolicy
+     * is designed to be shared across multiple stores / forks
+     * of the store.
+     *
+     * This invalidation is done automatically when using this service
+     * for both the CacheHandler and the LegacyNetworkHandler.
+     *
+     * ```ts
+     * store.lifetimes.invalidateRequestsForType(store, 'person');
+     * ```
+     *
+     * @public
+     * @param {String} type
+     * @param {Store} store
+     */
+    invalidateRequestsForType(type: string, store: Store): void;
+    /**
+     * Invoked when a request has been fulfilled from the configured request handlers.
+     * This is invoked by the CacheHandler for both foreground and background requests
+     * once the cache has been updated.
+     *
+     * Note, this is invoked by the CacheHandler regardless of whether
+     * the request has a cache-key.
+     *
+     * This method should not be invoked directly by consumers.
+     *
+     * @public
+     * @param {ImmutableRequestInfo} request
+     * @param {ImmutableResponse} response
+     * @param {Store} store
+     * @param {StableDocumentIdentifier | null} identifier
+     * @return {void}
+     */
+    didRequest(request: ImmutableRequestInfo, response: Response | ResponseInfo | null, identifier: StableDocumentIdentifier | null, store: Store): void;
+    /**
+     * Invoked to determine if the request may be fulfilled from cache
+     * if possible.
+     *
+     * Note, this is only invoked by the CacheHandler 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.
+     *
+     * @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 by the CacheHandler 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.
+     *
+     * @public
+     * @param {StableDocumentIdentifier} identifier
+     * @param {Store} store
+     * @return {Boolean} true if the request is considered soft expired
+     */
+    isSoftExpired(identifier: StableDocumentIdentifier, store: Store): boolean;
+}
+export {};
+//# sourceMappingURL=default-cache-policy.d.ts.map

package/declarations/store/-private/default-cache-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-cache-policy.d.ts","sourceRoot":"","sources":["../../../src/store/-private/default-cache-policy.ts"],"names":[],"mappings":"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"}

package/declarations/store/-private/legacy-model-support/record-reference.d.ts

@@ -0,0 +1,164 @@
+import type { StableRecordIdentifier } from '../../../types/identifier.ts';
+import type { SingleResourceDocument } from '../../../types/spec/json-api-raw.ts';
+import type { OpaqueRecordInstance } from '../../-types/q/record-instance.ts';
+import type { Store } from '../store-service.ts';
+/**
+   A `RecordReference` is a low-level API that allows users and
+   addon authors to perform meta-operations on a record.
+
+   @class RecordReference
+   @public
+*/
+export default class RecordReference {
+    store: Store;
+    ___token: object;
+    ___identifier: StableRecordIdentifier;
+    _ref: number;
+    constructor(store: Store, identifier: StableRecordIdentifier);
+    destroy(): void;
+    get type(): string;
+    /**
+       The `id` of the record that this reference refers to.
+  
+       Together, the `type` and `id` properties form a composite key for
+       the identity map.
+  
+       Example
+  
+       ```javascript
+       let userRef = store.getReference('user', 1);
+  
+       userRef.id(); // '1'
+       ```
+  
+      @public
+       @return {String} The id of the record.
+    */
+    id(): string | null;
+    /**
+       The `identifier` of the record that this reference refers to.
+  
+       Together, the `type` and `id` properties form a composite key for
+       the identity map.
+  
+       Example
+  
+       ```javascript
+       let userRef = store.getReference('user', 1);
+  
+       userRef.identifier(); // '1'
+       ```
+  
+      @public
+       @return {String} The identifier of the record.
+    */
+    identifier(): StableRecordIdentifier;
+    /**
+       How the reference will be looked up when it is loaded. Currently
+       this always returns `identity` to signify that a record will be
+       loaded by its `type` and `id`.
+  
+       Example
+  
+       ```javascript
+       const userRef = store.getReference('user', 1);
+  
+       userRef.remoteType(); // 'identity'
+       ```
+  
+       @public
+       @return {String} 'identity'
+    */
+    remoteType(): 'identity';
+    /**
+      This API allows you to provide a reference with new data. The
+      simplest usage of this API is similar to `store.push`: you provide a
+      normalized hash of data and the object represented by the reference
+      will update.
+  
+      If you pass a promise to `push`, Ember Data will not ask the adapter
+      for the data if another attempt to fetch it is made in the
+      interim. When the promise resolves, the underlying object is updated
+      with the new data, and the promise returned by *this function* is resolved
+      with that object.
+  
+      For example, `recordReference.push(promise)` will be resolved with a
+      record.
+  
+       Example
+  
+       ```javascript
+       let userRef = store.getReference('user', 1);
+  
+       // provide data for reference
+       userRef.push({
+         data: {
+           id: "1",
+           type: "user",
+           attributes: {
+             username: "@user"
+           }
+         }
+       }).then(function(user) {
+         userRef.value() === user;
+       });
+       ```
+  
+      @public
+      @param objectOrPromise a JSON:API ResourceDocument or a promise resolving to one
+      @return a promise for the value (record or relationship)
+    */
+    push(objectOrPromise: SingleResourceDocument | Promise<SingleResourceDocument>): Promise<OpaqueRecordInstance>;
+    /**
+      If the entity referred to by the reference is already loaded, it is
+      present as `reference.value`. Otherwise the value returned by this function
+      is `null`.
+  
+       Example
+  
+       ```javascript
+       let userRef = store.getReference('user', 1);
+  
+       userRef.value(); // user
+       ```
+  
+      @public
+       @return {Model} the record for this RecordReference
+    */
+    value(): OpaqueRecordInstance | null;
+    /**
+       Triggers a fetch for the backing entity based on its `remoteType`
+       (see `remoteType` definitions per reference type).
+  
+       Example
+  
+       ```javascript
+       let userRef = store.getReference('user', 1);
+  
+       // load user (via store.find)
+       userRef.load().then(...)
+       ```
+  
+      @public
+       @return {Promise<record>} the record for this RecordReference
+    */
+    load(): Promise<unknown>;
+    /**
+       Reloads the record if it is already loaded. If the record is not
+       loaded it will load the record via `store.findRecord`
+  
+       Example
+  
+       ```javascript
+       let userRef = store.getReference('user', 1);
+  
+       // or trigger a reload
+       userRef.reload().then(...)
+       ```
+  
+      @public
+       @return {Promise<record>} the record for this RecordReference
+    */
+    reload(): Promise<unknown>;
+}
+//# sourceMappingURL=record-reference.d.ts.map

package/declarations/store/-private/legacy-model-support/record-reference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"record-reference.d.ts","sourceRoot":"","sources":["../../../../src/store/-private/legacy-model-support/record-reference.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,8BAA8B,CAAC;AAC3E,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,qCAAqC,CAAC;AAClF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,mCAAmC,CAAC;AAG9E,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAEjD;;;;;;EAME;AACF,MAAM,CAAC,OAAO,OAAO,eAAe;IAC1B,KAAK,EAAE,KAAK,CAAC;IAErB,QAAQ,EAAG,MAAM,CAAC;IAClB,aAAa,EAAE,sBAAsB,CAAC;IAE9B,IAAI,EAAE,MAAM,CAAC;gBAET,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,sBAAsB;IAa5D,OAAO;IAIP,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;;;;;;;;;;;;;;;MAgBE;IACF,EAAE;IAMF;;;;;;;;;;;;;;;;MAgBE;IACF,UAAU,IAAI,sBAAsB;IAIpC;;;;;;;;;;;;;;;MAeE;IACF,UAAU,IAAI,UAAU;IAIxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAqCE;IACF,IAAI,CAAC,eAAe,EAAE,sBAAsB,GAAG,OAAO,CAAC,sBAAsB,CAAC,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAO9G;;;;;;;;;;;;;;;MAeE;IACF,KAAK,IAAI,oBAAoB,GAAG,IAAI;IAIpC;;;;;;;;;;;;;;;MAeE;IACF,IAAI;IAQJ;;;;;;;;;;;;;;;MAeE;IACF,MAAM;CAOP"}

package/declarations/store/-private/legacy-model-support/shim-model-class.d.ts

@@ -0,0 +1,17 @@
+import type { TypedRecordInstance, TypeFromInstance } from '../../../types/record.ts';
+import type { LegacyAttributeField, LegacyRelationshipField } from '../../../types/schema/fields.ts';
+import type { KeyOrString, ModelSchema } from '../../-types/q/ds-model.ts';
+import type { Store } from '../store-service.ts';
+export declare function getShimClass<T>(store: Store, modelName: T extends TypedRecordInstance ? TypeFromInstance<T> : string): ShimModelClass<T>;
+export default class ShimModelClass<T = unknown> implements ModelSchema<T> {
+    __store: Store;
+    modelName: T extends TypedRecordInstance ? TypeFromInstance<T> : string;
+    constructor(store: Store, modelName: T extends TypedRecordInstance ? TypeFromInstance<T> : string);
+    get fields(): Map<KeyOrString<T>, 'attribute' | 'belongsTo' | 'hasMany'>;
+    get attributes(): Map<KeyOrString<T>, LegacyAttributeField>;
+    get relationshipsByName(): Map<KeyOrString<T>, LegacyRelationshipField>;
+    eachAttribute<K extends KeyOrString<T>>(callback: (key: K, attribute: LegacyAttributeField) => void, binding?: T): void;
+    eachRelationship<K extends KeyOrString<T>>(callback: (key: K, relationship: LegacyRelationshipField) => void, binding?: T): void;
+    eachTransformedAttribute<K extends KeyOrString<T>>(callback: (key: K, type: string | null) => void, binding?: T): void;
+}
+//# sourceMappingURL=shim-model-class.d.ts.map

package/declarations/store/-private/legacy-model-support/shim-model-class.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shim-model-class.d.ts","sourceRoot":"","sources":["../../../../src/store/-private/legacy-model-support/shim-model-class.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AACtF,OAAO,KAAK,EAAE,oBAAoB,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAC;AACrG,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAC3E,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAMjD,wBAAgB,YAAY,CAAC,CAAC,EAC5B,KAAK,EAAE,KAAK,EACZ,SAAS,EAAE,CAAC,SAAS,mBAAmB,GAAG,gBAAgB,CAAC,CAAC,CAAC,GAAG,MAAM,GACtE,cAAc,CAAC,CAAC,CAAC,CAcnB;AAGD,MAAM,CAAC,OAAO,OAAO,cAAc,CAAC,CAAC,GAAG,OAAO,CAAE,YAAW,WAAW,CAAC,CAAC,CAAC;IAChE,OAAO,EAAE,KAAK,CAAC;IACf,SAAS,EAAE,CAAC,SAAS,mBAAmB,GAAG,gBAAgB,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC;gBACpE,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC,SAAS,mBAAmB,GAAG,gBAAgB,CAAC,CAAC,CAAC,GAAG,MAAM;IAKjG,IAAI,MAAM,IAAI,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,WAAW,GAAG,WAAW,GAAG,SAAS,CAAC,CAWvE;IAED,IAAI,UAAU,IAAI,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,oBAAoB,CAAC,CAW1D;IAED,IAAI,mBAAmB,IAAI,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,uBAAuB,CAAC,CAWtE;IAED,aAAa,CAAC,CAAC,SAAS,WAAW,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,SAAS,EAAE,oBAAoB,KAAK,IAAI,EAAE,OAAO,CAAC,EAAE,CAAC;IAQhH,gBAAgB,CAAC,CAAC,SAAS,WAAW,CAAC,CAAC,CAAC,EACvC,QAAQ,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,YAAY,EAAE,uBAAuB,KAAK,IAAI,EACjE,OAAO,CAAC,EAAE,CAAC;IASb,wBAAwB,CAAC,CAAC,SAAS,WAAW,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,EAAE,OAAO,CAAC,EAAE,CAAC;CAQhH"}

package/declarations/store/-private/managers/cache-capabilities-manager.d.ts

@@ -0,0 +1,26 @@
+import type { StableDocumentIdentifier, StableRecordIdentifier } from '../../../types/identifier.ts';
+import type { CacheCapabilitiesManager as StoreWrapper } from '../../-types/q/cache-capabilities-manager.ts';
+import type { SchemaService } from '../../-types/q/schema-service.ts';
+import type { IdentifierCache } from '../caches/identifier-cache.ts';
+import type { Store } from '../store-service.ts';
+import type { NotificationType } from './notification-manager.ts';
+export interface CacheCapabilitiesManager {
+    getSchemaDefinitionService(): SchemaService;
+}
+export declare class CacheCapabilitiesManager implements StoreWrapper {
+    _willNotify: boolean;
+    _pendingNotifies: Map<StableRecordIdentifier, Set<string>>;
+    _store: Store;
+    constructor(_store: Store);
+    get identifierCache(): IdentifierCache;
+    _scheduleNotification(identifier: StableRecordIdentifier, key: string): void;
+    _flushNotifications(): void;
+    notifyChange(identifier: StableRecordIdentifier, namespace: 'added' | 'removed', key: null): void;
+    notifyChange(identifier: StableDocumentIdentifier, namespace: 'added' | 'updated' | 'removed', key: null): void;
+    notifyChange(identifier: StableRecordIdentifier, namespace: NotificationType, key: string | null): void;
+    get schema(): SchemaService;
+    setRecordId(identifier: StableRecordIdentifier, id: string): void;
+    hasRecord(identifier: StableRecordIdentifier): boolean;
+    disconnectRecord(identifier: StableRecordIdentifier): void;
+}
+//# sourceMappingURL=cache-capabilities-manager.d.ts.map

package/declarations/store/-private/managers/cache-capabilities-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache-capabilities-manager.d.ts","sourceRoot":"","sources":["../../../../src/store/-private/managers/cache-capabilities-manager.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,wBAAwB,EAAE,sBAAsB,EAAE,MAAM,8BAA8B,CAAC;AACrG,OAAO,KAAK,EAAE,wBAAwB,IAAI,YAAY,EAAE,MAAM,8CAA8C,CAAC;AAC7G,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kCAAkC,CAAC;AACtE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAErE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAElE,MAAM,WAAW,wBAAwB;IACvC,0BAA0B,IAAI,aAAa,CAAC;CAC7C;AACD,qBAAa,wBAAyB,YAAW,YAAY;IACnD,WAAW,EAAE,OAAO,CAAC;IACrB,gBAAgB,EAAE,GAAG,CAAC,sBAAsB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;IAC3D,MAAM,EAAE,KAAK,CAAC;gBAEV,MAAM,EAAE,KAAK;IAMzB,IAAI,eAAe,IAAI,eAAe,CAErC;IAED,qBAAqB,CAAC,UAAU,EAAE,sBAAsB,EAAE,GAAG,EAAE,MAAM;IAyBrE,mBAAmB,IAAI,IAAI;IAgB3B,YAAY,CAAC,UAAU,EAAE,sBAAsB,EAAE,SAAS,EAAE,OAAO,GAAG,SAAS,EAAE,GAAG,EAAE,IAAI,GAAG,IAAI;IACjG,YAAY,CAAC,UAAU,EAAE,wBAAwB,EAAE,SAAS,EAAE,OAAO,GAAG,SAAS,GAAG,SAAS,EAAE,GAAG,EAAE,IAAI,GAAG,IAAI;IAC/G,YAAY,CAAC,UAAU,EAAE,sBAAsB,EAAE,SAAS,EAAE,gBAAgB,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI;IAkBvG,IAAI,MAAM,kBAET;IAED,WAAW,CAAC,UAAU,EAAE,sBAAsB,EAAE,EAAE,EAAE,MAAM;IAK1D,SAAS,CAAC,UAAU,EAAE,sBAAsB,GAAG,OAAO;IAItD,gBAAgB,CAAC,UAAU,EAAE,sBAAsB,GAAG,IAAI;CAK3D"}