@warp-drive/core 5.6.0-alpha.14 → 5.6.0-alpha.17

package/declarations/store/-private/utils/coerce-id.d.ts

@@ -1,5 +1,10 @@
+// Used by the store to normalize IDs entering the store.  Despite the fact
+// that developers may provide IDs as numbers (e.g., `store.findRecord('person', 1)`),
+// it is important that internally we use strings, since IDs may be serialized
+// and lose type information.  For example, Ember's router may put a record's
+// ID into the URL, and if we later try to deserialize that URL and find the
+// corresponding record, we will not know if it is a string or a number.
 type Coercable = string | number | boolean | null | undefined | symbol;
 export declare function coerceId(id: unknown): string | null;
 export declare function ensureStringId(id: Coercable): string;
 export {};
-//# sourceMappingURL=coerce-id.d.ts.map

package/declarations/store/-private/utils/construct-resource.d.ts

@@ -1,7 +1,6 @@
-import type { ExistingResourceIdentifierObject, ResourceIdentifierObject } from '../../../types/spec/json-api-raw.ts';
+import type { ExistingResourceIdentifierObject, ResourceIdentifierObject } from "../../../types/spec/json-api-raw.js";
 export declare function constructResource(type: ResourceIdentifierObject): ResourceIdentifierObject;
 export declare function constructResource(type: string, id: string, lid: string): ExistingResourceIdentifierObject;
 export declare function constructResource(type: string | undefined, id: null | undefined, lid: string): ExistingResourceIdentifierObject;
 export declare function constructResource(type: string, id: string, lid?: string | null): ExistingResourceIdentifierObject;
 export declare function constructResource(type: string, id?: string | number | null, lid?: string | null): ResourceIdentifierObject;
-//# sourceMappingURL=construct-resource.d.ts.map

package/declarations/store/-private/utils/is-non-empty-string.d.ts

@@ -1,2 +1 @@
 export declare function isNonEmptyString(str: unknown): str is string;
-//# sourceMappingURL=is-non-empty-string.d.ts.map

package/declarations/store/-private/utils/normalize-model-name.d.ts

@@ -1,2 +1 @@
 export declare function normalizeModelName(type: string): string;
-//# sourceMappingURL=normalize-model-name.d.ts.map

package/declarations/store/-private/utils/uuid-polyfill.d.ts

@@ -1,2 +1 @@
 export default function installPolyfill(): void;
-//# sourceMappingURL=uuid-polyfill.d.ts.map

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

@@ -1,27 +1,31 @@
-export { Store, storeFor } from './-private/store-service.ts';
-export { recordIdentifierFor } from './-private/caches/instance-cache.ts';
-export { CacheHandler, type StoreRequestContext } from './-private/cache-handler/handler.ts';
-export { type CachePolicy } from './-private/cache-handler/types.ts';
-export { isStableIdentifier, isDocumentIdentifier } from './-private/caches/identifier-cache.ts';
-export { constructResource } from './-private/utils/construct-resource.ts';
-export type { InstanceCache } from './-private/caches/instance-cache.ts';
-export type { FindRecordQuery, Request, SaveRecordMutation, RequestCacheRequestState, RequestStateService, } from './-private/network/request-cache.ts';
-export type { CreateRecordProperties } from './-private/store-service.ts';
-export { coerceId, ensureStringId } from './-private/utils/coerce-id.ts';
-export type { NativeProxy } from './-private/record-arrays/native-proxy-type-fix.ts';
-export { IdentifierArray as LiveArray, Collection as CollectionRecordArray, SOURCE, MUTATE, } from './-private/record-arrays/identifier-array.ts';
-export { RecordArrayManager, fastPush } from './-private/managers/record-array-manager.ts';
-export { _clearCaches } from './-private/caches/instance-cache.ts';
-export { peekCache, removeRecordDataFor } from './-private/caches/cache-utils.ts';
-export { setRecordIdentifier, StoreMap } from './-private/caches/instance-cache.ts';
-export { setCacheFor } from './-private/caches/cache-utils';
-export { normalizeModelName as _deprecatingNormalize } from './-private/utils/normalize-model-name.ts';
-export type { StoreRequestInput } from './-private/cache-handler/handler.ts';
-export { RelatedCollection } from './-private/record-arrays/many-array.ts';
-export { log, logGroup } from './-private/debug/utils';
-export { getPromiseState, type PromiseState } from './-private/new-core-tmp/promise-state.ts';
-export { getRequestState, type RequestLoadingState, type RequestCacheRequestState as RequestState, } from './-private/new-core-tmp/request-state.ts';
-export { createMemo, type SignalHooks, waitFor } from './-private/new-core-tmp/reactivity/configure.ts';
-export { memoized, gate, entangleSignal, defineSignal, defineNonEnumerableSignal, } from './-private/new-core-tmp/reactivity/signal.ts';
-export { ARRAY_SIGNAL, OBJECT_SIGNAL, Signals, type WarpDriveSignal, peekInternalSignal, withSignalStore, notifyInternalSignal, consumeInternalSignal, getOrCreateInternalSignal, } from './-private/new-core-tmp/reactivity/internal.ts';
-//# sourceMappingURL=-private.d.ts.map
+export { Store, storeFor } from "./-private/store-service.js";
+export { recordIdentifierFor } from "./-private/caches/instance-cache.js";
+export { CacheHandler, type StoreRequestContext } from "./-private/cache-handler/handler.js";
+export { type CachePolicy } from "./-private/cache-handler/types.js";
+export { isStableIdentifier, isDocumentIdentifier } from "./-private/caches/identifier-cache.js";
+export { constructResource } from "./-private/utils/construct-resource.js";
+export type { InstanceCache } from "./-private/caches/instance-cache.js";
+export type { FindRecordQuery, Request, SaveRecordMutation, RequestCacheRequestState, RequestStateService } from "./-private/network/request-cache.js";
+export type { CreateRecordProperties } from "./-private/store-service.js";
+// TODO this should be a deprecated helper but we have so much usage of it
+// to also eliminate
+export { coerceId, ensureStringId } from "./-private/utils/coerce-id.js";
+export type { NativeProxy } from "./-private/record-arrays/native-proxy-type-fix.js";
+export { IdentifierArray as LiveArray, Collection as CollectionRecordArray, SOURCE, MUTATE } from "./-private/record-arrays/identifier-array.js";
+export { RecordArrayManager, fastPush } from "./-private/managers/record-array-manager.js";
+// leaked for private use / test use, should investigate removing
+export { _clearCaches } from "./-private/caches/instance-cache.js";
+export { peekCache, removeRecordDataFor } from "./-private/caches/cache-utils.js";
+// @ember-data/model needs these temporarily
+export { setRecordIdentifier, StoreMap } from "./-private/caches/instance-cache.js";
+export { setCacheFor } from "./-private/caches/cache-utils.js";
+export { normalizeModelName as _deprecatingNormalize } from "./-private/utils/normalize-model-name.js";
+export type { StoreRequestInput } from "./-private/cache-handler/handler.js";
+export { RelatedCollection } from "./-private/record-arrays/many-array.js";
+export { log, logGroup } from "./-private/debug/utils.js";
+export { getPromiseState, type PromiseState } from "./-private/new-core-tmp/promise-state.js";
+export { DISPOSE, createRequestSubscription, type SubscriptionArgs, type RequestSubscription } from "./-private/new-core-tmp/request-subscription.js";
+export { getRequestState, type RequestLoadingState, type RequestCacheRequestState as RequestState } from "./-private/new-core-tmp/request-state.js";
+export { createMemo, type SignalHooks, waitFor } from "./-private/new-core-tmp/reactivity/configure.js";
+export { memoized, gate, entangleSignal, defineSignal, defineNonEnumerableSignal } from "./-private/new-core-tmp/reactivity/signal.js";
+export { ARRAY_SIGNAL, OBJECT_SIGNAL, Signals, type WarpDriveSignal, peekInternalSignal, withSignalStore, notifyInternalSignal, consumeInternalSignal, getOrCreateInternalSignal } from "./-private/new-core-tmp/reactivity/internal.js";

package/declarations/store/-types/q/cache-capabilities-manager.d.ts

@@ -1,100 +1,99 @@
-import type { StableDocumentIdentifier, StableRecordIdentifier } from '../../../types/identifier.ts';
-import type { IdentifierCache } from '../../-private/caches/identifier-cache.ts';
-import type { NotificationType } from '../../-private/managers/notification-manager.ts';
-import type { SchemaService } from './schema-service.ts';
+import type { StableDocumentIdentifier, StableRecordIdentifier } from "../../../types/identifier.js";
+import type { IdentifierCache } from "../../-private/caches/identifier-cache.js";
+import type { NotificationType } from "../../-private/managers/notification-manager.js";
+import type { SchemaService } from "./schema-service.js";
 /**
- * CacheCapabilitiesManager provides encapsulated API access to the minimal
- * subset of the Store's functionality that Cache implementations
- * should interact with. It is provided to the Store's `createCache` hook.
- *
- * Cache implementations should not need more than this API provides.
- *
- * This class cannot be directly instantiated.
- *
- * @class CacheCapabilitiesManager
- * @public
- */
+* CacheCapabilitiesManager provides encapsulated API access to the minimal
+* subset of the Store's functionality that Cache implementations
+* should interact with. It is provided to the Store's `createCache` hook.
+*
+* Cache implementations should not need more than this API provides.
+*
+* This class cannot be directly instantiated.
+*
+* @class CacheCapabilitiesManager
+* @public
+*/
 export type CacheCapabilitiesManager = {
-    /**
-     * Provides access to the IdentifierCache instance
-     * for this Store instance.
-     *
-     * The IdentifierCache can be used to peek, generate or
-     * retrieve a stable unique identifier for any resource.
-     *
-     * @property identifierCache
-     * @type {IdentifierCache}
-     * @public
-     */
-    identifierCache: IdentifierCache;
-    /**
-     * DEPRECATED - use the schema property
-     *
-     * Provides access to the SchemaService instance
-     * for this Store instance.
-     *
-     * The SchemaService can be used to query for
-     * information about the schema of a resource.
-     *
-     * @deprecated
-     * @public
-     */
-    getSchemaDefinitionService(): SchemaService;
-    /**
-     * Provides access to the SchemaService instance
-     * for this Store instance.
-     *
-     * The SchemaService can be used to query for
-     * information about the schema of a resource.
-     *
-     * @property schema
-     * @public
-     */
-    schema: SchemaService;
-    /**
-     * Update the `id` for the record corresponding to the identifier
-     * This operation can only be done for records whose `id` is `null`.
-     *
-     * @param {StableRecordIdentifier} identifier;
-     * @param {String} id;
-     * @public
-     */
-    setRecordId(identifier: StableRecordIdentifier, id: string): void;
-    /**
-     * Signal to the store that the specified record may be considered fully
-     * removed from the cache. Generally this means that not only does no
-     * data exist for the identified resource, no known relationships still
-     * point to it either.
-     *
-     * @param {StableRecordIdentifier} identifier
-     * @public
-     */
-    disconnectRecord(identifier: StableRecordIdentifier): void;
-    /**
-     * Use this method to determine if the Store has an instantiated record associated
-     * with an identifier.
-     *
-     * @param identifier
-     * @return {Boolean}
-     * @public
-     */
-    hasRecord(identifier: StableRecordIdentifier): boolean;
-    /**
-     * Notify subscribers of the NotificationManager that cache state has changed.
-     *
-     * `attributes` and `relationships` do not require a key, but if one is specified it
-     * is assumed to be the name of the attribute or relationship that has been updated.
-     *
-     * No other namespaces currently expect the `key` argument.
-     *
-     * @param {StableRecordIdentifier} identifier
-     * @param {'attributes' | 'relationships' | 'identity' | 'errors' | 'meta' | 'state'} namespace
-     * @param {string|undefined} key
-     * @public
-     */
-    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;
-    notifyChange(identifier: StableRecordIdentifier | StableDocumentIdentifier, namespace: NotificationType | 'added' | 'removed' | 'updated', key: string | null): void;
+	/**
+	* Provides access to the IdentifierCache instance
+	* for this Store instance.
+	*
+	* The IdentifierCache can be used to peek, generate or
+	* retrieve a stable unique identifier for any resource.
+	*
+	* @property identifierCache
+	* @type {IdentifierCache}
+	* @public
+	*/
+	identifierCache: IdentifierCache;
+	/**
+	* DEPRECATED - use the schema property
+	*
+	* Provides access to the SchemaService instance
+	* for this Store instance.
+	*
+	* The SchemaService can be used to query for
+	* information about the schema of a resource.
+	*
+	* @deprecated
+	* @public
+	*/
+	getSchemaDefinitionService(): SchemaService;
+	/**
+	* Provides access to the SchemaService instance
+	* for this Store instance.
+	*
+	* The SchemaService can be used to query for
+	* information about the schema of a resource.
+	*
+	* @property schema
+	* @public
+	*/
+	schema: SchemaService;
+	/**
+	* Update the `id` for the record corresponding to the identifier
+	* This operation can only be done for records whose `id` is `null`.
+	*
+	* @param {StableRecordIdentifier} identifier;
+	* @param {String} id;
+	* @public
+	*/
+	setRecordId(identifier: StableRecordIdentifier, id: string): void;
+	/**
+	* Signal to the store that the specified record may be considered fully
+	* removed from the cache. Generally this means that not only does no
+	* data exist for the identified resource, no known relationships still
+	* point to it either.
+	*
+	* @param {StableRecordIdentifier} identifier
+	* @public
+	*/
+	disconnectRecord(identifier: StableRecordIdentifier): void;
+	/**
+	* Use this method to determine if the Store has an instantiated record associated
+	* with an identifier.
+	*
+	* @param identifier
+	* @return {Boolean}
+	* @public
+	*/
+	hasRecord(identifier: StableRecordIdentifier): boolean;
+	/**
+	* Notify subscribers of the NotificationManager that cache state has changed.
+	*
+	* `attributes` and `relationships` do not require a key, but if one is specified it
+	* is assumed to be the name of the attribute or relationship that has been updated.
+	*
+	* No other namespaces currently expect the `key` argument.
+	*
+	* @param {StableRecordIdentifier} identifier
+	* @param {'attributes' | 'relationships' | 'identity' | 'errors' | 'meta' | 'state'} namespace
+	* @param {string|undefined} key
+	* @public
+	*/
+	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;
+	notifyChange(identifier: StableRecordIdentifier | StableDocumentIdentifier, namespace: NotificationType | "added" | "removed" | "updated", key: string | null): void;
 };
-//# sourceMappingURL=cache-capabilities-manager.d.ts.map

package/declarations/store/-types/q/ds-model.d.ts

@@ -1,22 +1,21 @@
-import type { TypedRecordInstance, TypeFromInstance } from '../../../types/record.ts';
-import type { LegacyAttributeField, LegacyRelationshipField } from '../../../types/schema/fields.ts';
+import type { TypedRecordInstance, TypeFromInstance } from "../../../types/record.js";
+import type { LegacyAttributeField, LegacyRelationshipField } from "../../../types/schema/fields.js";
 export type KeyOrString<T> = keyof T & string extends never ? string : keyof T & string;
 /**
- * Minimum subset of static schema methods and properties on the
- * "model" class.
- *
- * Only used when using the legacy schema-service implementation
- * for @ember-data/model or when wrapping schema for legacy
- * Adapters/Serializers.
- *
- */
+* Minimum subset of static schema methods and properties on the
+* "model" class.
+*
+* Only used when using the legacy schema-service implementation
+* for @ember-data/model or when wrapping schema for legacy
+* Adapters/Serializers.
+*
+*/
 export interface ModelSchema<T = unknown> {
-    modelName: T extends TypedRecordInstance ? TypeFromInstance<T> : string;
-    fields: Map<KeyOrString<T>, 'attribute' | 'belongsTo' | 'hasMany'>;
-    attributes: Map<KeyOrString<T>, LegacyAttributeField>;
-    relationshipsByName: Map<KeyOrString<T>, LegacyRelationshipField>;
-    eachAttribute<K extends KeyOrString<T>>(callback: (this: ModelSchema<T>, key: K, attribute: LegacyAttributeField) => void, binding?: T): void;
-    eachRelationship<K extends KeyOrString<T>>(callback: (this: ModelSchema<T>, key: K, relationship: LegacyRelationshipField) => void, binding?: T): void;
-    eachTransformedAttribute<K extends KeyOrString<T>>(callback: (this: ModelSchema<T>, key: K, type: string | null) => void, binding?: T): void;
+	modelName: T extends TypedRecordInstance ? TypeFromInstance<T> : string;
+	fields: Map<KeyOrString<T>, "attribute" | "belongsTo" | "hasMany">;
+	attributes: Map<KeyOrString<T>, LegacyAttributeField>;
+	relationshipsByName: Map<KeyOrString<T>, LegacyRelationshipField>;
+	eachAttribute<K extends KeyOrString<T>>(callback: (this: ModelSchema<T>, key: K, attribute: LegacyAttributeField) => void, binding?: T): void;
+	eachRelationship<K extends KeyOrString<T>>(callback: (this: ModelSchema<T>, key: K, relationship: LegacyRelationshipField) => void, binding?: T): void;
+	eachTransformedAttribute<K extends KeyOrString<T>>(callback: (this: ModelSchema<T>, key: K, type: string | null) => void, binding?: T): void;
 }
-//# sourceMappingURL=ds-model.d.ts.map

package/declarations/store/-types/q/identifier.d.ts

@@ -1,21 +1,20 @@
-import type { IdentifierBucket, StableIdentifier, StableRecordIdentifier } from '../../../types/identifier.ts';
-import type { ImmutableRequestInfo } from '../../../types/request.ts';
+import type { IdentifierBucket, StableIdentifier, StableRecordIdentifier } from "../../../types/identifier.js";
+import type { ImmutableRequestInfo } from "../../../types/request.js";
 export interface GenerationMethod {
-    (data: ImmutableRequestInfo, bucket: 'document'): string | null;
-    (data: unknown | {
-        type: string;
-    }, bucket: 'record'): string;
-    (data: unknown, bucket: IdentifierBucket): string | null;
+	(data: ImmutableRequestInfo, bucket: "document"): string | null;
+	(data: unknown | {
+		type: string;
+	}, bucket: "record"): string;
+	(data: unknown, bucket: IdentifierBucket): string | null;
 }
 export type UpdateMethod = {
-    (identifier: StableRecordIdentifier, newData: unknown, bucket: 'record'): void;
-    (identifier: StableIdentifier, newData: unknown, bucket: never): void;
+	(identifier: StableRecordIdentifier, newData: unknown, bucket: "record"): void;
+	(identifier: StableIdentifier, newData: unknown, bucket: never): void;
 };
 export type ForgetMethod = (identifier: StableIdentifier | StableRecordIdentifier, bucket: IdentifierBucket) => void;
 export type ResetMethod = () => void;
 export type KeyInfo = {
-    id: string | null;
-    type: string;
+	id: string | null;
+	type: string;
 };
 export type KeyInfoMethod = (resource: unknown, known: StableRecordIdentifier | null) => KeyInfo;
-//# sourceMappingURL=identifier.d.ts.map

package/declarations/store/-types/q/record-instance.d.ts

@@ -1,24 +1,23 @@
 /**
-  In WarpDrive, a "record instance" is a class instance used to present the data
-  for a single resource, transforming the resource's cached raw data into a form
-  that is useful for the application.
+In WarpDrive, a "record instance" is a class instance used to present the data
+for a single resource, transforming the resource's cached raw data into a form
+that is useful for the application.
 
-  Since every application's needs are different, WarpDrive does not assume to know
-  what the shape of the record instance should be. Instead, it provides a way to
-  define the record instance's via the `instantiateRecord` hook on the store.
+Since every application's needs are different, WarpDrive does not assume to know
+what the shape of the record instance should be. Instead, it provides a way to
+define the record instance's via the `instantiateRecord` hook on the store.
 
-  Thus for most purposes the `RecordInstance` type is "opaque" to WarpDrive, and
-  should be treated as "unknown" by the library.
+Thus for most purposes the `RecordInstance` type is "opaque" to WarpDrive, and
+should be treated as "unknown" by the library.
 
-  Wherever possible, if typing an API that is consumer facing, instead of using
-  OpaqueRecordInstance, we should prefer to use a generic and check if the generic
-  extends `TypedRecordInstance`. This allows consumers to define their own record
-  instance types and not only have their types flow through WarpDrive APIs, but
-  also allows WarpDrive to provide typechecking and intellisense for the record
-  based on a special symbol prsent on record instances that implement the
-  `TypedRecordInstance` interface.
+Wherever possible, if typing an API that is consumer facing, instead of using
+OpaqueRecordInstance, we should prefer to use a generic and check if the generic
+extends `TypedRecordInstance`. This allows consumers to define their own record
+instance types and not only have their types flow through WarpDrive APIs, but
+also allows WarpDrive to provide typechecking and intellisense for the record
+based on a special symbol prsent on record instances that implement the
+`TypedRecordInstance` interface.
 
-  @internal
+@internal
 */
 export type OpaqueRecordInstance = unknown;
-//# sourceMappingURL=record-instance.d.ts.map