@warp-drive/core 5.8.0-alpha.3 → 5.8.0-alpha.32

package/dist/unpkg/dev-deprecated/declarations/store/-private/utils/coerce-id.d.ts

@@ -0,0 +1,4 @@
+type Coercable = string | number | boolean | null | undefined | symbol;
+export declare function coerceId(id: unknown): string | null;
+export declare function ensureStringId(id: Coercable): string;
+export {};

package/dist/unpkg/dev-deprecated/declarations/store/-private/utils/construct-resource.d.ts

@@ -0,0 +1,6 @@
+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;

package/dist/unpkg/dev-deprecated/declarations/store/-private/utils/is-non-empty-string.d.ts

@@ -0,0 +1 @@
+export declare function isNonEmptyString(str: unknown): str is string;

package/dist/unpkg/dev-deprecated/declarations/store/-private/utils/normalize-model-name.d.ts

@@ -0,0 +1 @@
+export declare function normalizeModelName(type: string): string;

package/dist/unpkg/dev-deprecated/declarations/store/-private/utils/uuid-polyfill.d.ts

@@ -0,0 +1 @@
+export default function installPolyfill(): void;

package/dist/unpkg/dev-deprecated/declarations/store/-private.d.ts

@@ -0,0 +1,29 @@
+export { Store } from "./deprecated/store.js";
+export { 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 { isResourceKey, isRequestKey } from "./-private/managers/cache-key-manager.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";
+export { coerceId, ensureStringId } from "./-private/utils/coerce-id.js";
+export type { NativeProxy } from "./-private/record-arrays/native-proxy-type-fix.js";
+export { type ReactiveResourceArray, type PrivateReactiveResourceArray } from "./-private/record-arrays/resource-array.js";
+export { type LegacyLiveArray, type LegacyLiveArray as LiveArray } from "./-private/record-arrays/legacy-live-array.js";
+export { type LegacyQueryArray, type LegacyQueryArray as CollectionRecordArray } from "./-private/record-arrays/legacy-query.js";
+export { RecordArrayManager, fastPush } from "./-private/managers/record-array-manager.js";
+export { assertPrivateStore, isPrivateStore, type PrivateStore } from "./-private/store-service.js";
+export { assertPrivateCapabilities, type PrivateCacheCapabilitiesManager } from "./-private/managers/cache-capabilities-manager.js";
+export { _clearCaches } from "./-private/caches/instance-cache.js";
+export { setRecordIdentifier, StoreMap } from "./-private/caches/instance-cache.js";
+export { normalizeModelName as _deprecatingNormalize } from "./-private/utils/normalize-model-name.js";
+export type { StoreRequestInput } from "./-private/cache-handler/handler.js";
+export { type LegacyManyArray, type LegacyManyArray as RelatedCollection, createLegacyManyArray } from "./-private/record-arrays/legacy-many-array.js";
+export { log, logGroup } from "./-private/debug/utils.js";
+export { DISPOSE, createRequestSubscription, type RequestArgs, type SubscriptionArgs, type RequestComponentArgs, type RequestSubscription, type ContentFeatures, type RecoveryFeatures, type AutorefreshBehaviorCombos, type AutorefreshBehaviorType } 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 { type SignalHooks, waitFor } from "./-private/new-core-tmp/reactivity/configure.js";
+export { signal, memoized, gate, entangleSignal, entangleInitiallyStaleSignal, defineSignal, defineGate, defineNonEnumerableSignal } from "./-private/new-core-tmp/reactivity/signal.js";
+export { ARRAY_SIGNAL, OBJECT_SIGNAL, Signals, type WarpDriveSignal, peekInternalSignal, createInternalMemo, withSignalStore, notifyInternalSignal, consumeInternalSignal, getOrCreateInternalSignal } from "./-private/new-core-tmp/reactivity/internal.js";

package/dist/unpkg/dev-deprecated/declarations/store/-types/q/cache-capabilities-manager.d.ts

@@ -0,0 +1,90 @@
+import type { RequestKey, ResourceKey } from "../../../types/identifier.js";
+import type { SchemaService } from "../../../types/schema/schema-service.js";
+import type { CacheKeyManager } from "../../-private/managers/cache-key-manager.js";
+import type { NotificationType } from "../../-private/managers/notification-manager.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.
+*
+* @public
+*/
+export type CacheCapabilitiesManager = {
+	/**
+	* Provides access to the CacheKeyManager instance
+	* for this Store instance.
+	*
+	* The CacheKeyManager can be used to peek, generate or
+	* retrieve a stable unique identifier for any resource.
+	*
+	* @public
+	*/
+	cacheKeyManager: CacheKeyManager;
+	/** @deprecated use {@link CacheCapabilitiesManager.cacheKeyManager} */
+	identifierCache: CacheKeyManager;
+	/**
+	* 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 use {@link CacheCapabilitiesManager.schema}
+	* @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`.
+	*
+	* @public
+	*/
+	setRecordId(identifier: ResourceKey, 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.
+	*
+	* @public
+	*/
+	disconnectRecord(identifier: ResourceKey): void;
+	/**
+	* Use this method to determine if the Store has an instantiated record associated
+	* with an identifier.
+	*
+	* @public
+	*/
+	hasRecord(identifier: ResourceKey): 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.
+	*
+	* @public
+	*/
+	notifyChange(identifier: ResourceKey, namespace: "added" | "removed", key: null): void;
+	notifyChange(identifier: RequestKey, namespace: "added" | "updated" | "removed", key: null): void;
+	notifyChange(identifier: ResourceKey, namespace: NotificationType, key: string | null): void;
+	notifyChange(identifier: ResourceKey | RequestKey, namespace: NotificationType | "added" | "removed" | "updated", key: string | null): void;
+};

package/dist/unpkg/dev-deprecated/declarations/store/-types/q/identifier.d.ts

@@ -0,0 +1,23 @@
+import type { CacheKeyType, RequestKey, ResourceKey } 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: CacheKeyType): string | null;
+}
+export type UpdateMethod = {
+	(identifier: ResourceKey, newData: unknown, bucket: "record"): void;
+	(identifier: RequestKey, newData: unknown, bucket: "document"): void;
+	(identifier: {
+		lid: string;
+	}, newData: unknown, bucket: never): void;
+};
+export type ForgetMethod = (identifier: RequestKey | ResourceKey, bucket: CacheKeyType) => void;
+export type ResetMethod = () => void;
+export type KeyInfo = {
+	id: string | null;
+	type: string;
+};
+export type KeyInfoMethod = (resource: unknown, known: ResourceKey | null) => KeyInfo;

package/dist/unpkg/dev-deprecated/declarations/store/-types/q/record-instance.d.ts

@@ -0,0 +1,22 @@
+/**
+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.
+
+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.
+
+*/
+export type OpaqueRecordInstance = unknown;

package/dist/unpkg/dev-deprecated/declarations/store/-types/q/store.d.ts

@@ -0,0 +1,31 @@
+import type { Value } from "../../../types/json/raw.js";
+export interface BaseFinderOptions {
+	reload?: boolean;
+	backgroundReload?: boolean;
+	include?: string | string[];
+	adapterOptions?: Record<string, unknown>;
+}
+export interface FindRecordOptions extends BaseFinderOptions {
+	/**
+	* Data to preload into the store before the request is made.
+	* This feature is *highly* discouraged and has no corresponding
+	* feature when using builders and handlers.
+	*
+	* Excepting relationships: the data should be in the form of a
+	* JSON object where the keys are fields on the record and the value
+	* is the raw value to be added to the cache.
+	*
+	* Relationships can either be provided as string IDs from which
+	* an identifier will be built base upon the relationship's expected
+	* resource type, or be record instances from which the identifier
+	* will be extracted.
+	*
+	*/
+	preload?: Record<string, Value>;
+}
+export type QueryOptions = { [K in string | "adapterOptions"]? : K extends "adapterOptions" ? Record<string, unknown> : unknown };
+export type FindAllOptions = BaseFinderOptions;
+export type LegacyResourceQuery = {
+	include?: string | string[];
+	[key: string]: Value | undefined;
+};

package/dist/unpkg/dev-deprecated/declarations/store/deprecated/-private.d.ts

@@ -0,0 +1,223 @@
+import type { NewResourceKey, ResourceKey } from "../../types/identifier.js";
+import type { Value } from "../../types/json/raw.js";
+import type { OpaqueRecordInstance, TypedRecordInstance, TypeFromInstance } from "../../types/record.js";
+import type { LegacyAttributeField, LegacyRelationshipField } from "../../types/schema/fields.js";
+import type { SingleResourceDocument } from "../../types/spec/json-api-raw.js";
+import { type InstanceCache } from "../-private.js";
+import type { Store } from "./store.js";
+export declare function preloadData(store: Store, identifier: NewResourceKey, preload: Record<string, Value>): void;
+export interface BaseFinderOptions {
+	reload?: boolean;
+	backgroundReload?: boolean;
+	include?: string | string[];
+	adapterOptions?: Record<string, unknown>;
+}
+export interface FindRecordOptions extends BaseFinderOptions {
+	/**
+	* Data to preload into the store before the request is made.
+	* This feature is *highly* discouraged and has no corresponding
+	* feature when using builders and handlers.
+	*
+	* Excepting relationships: the data should be in the form of a
+	* JSON object where the keys are fields on the record and the value
+	* is the raw value to be added to the cache.
+	*
+	* Relationships can either be provided as string IDs from which
+	* an identifier will be built base upon the relationship's expected
+	* resource type, or be record instances from which the identifier
+	* will be extracted.
+	*
+	*/
+	preload?: Record<string, Value>;
+}
+export type QueryOptions = { [K in string | "adapterOptions"]? : K extends "adapterOptions" ? Record<string, unknown> : unknown };
+export type FindAllOptions = BaseFinderOptions;
+export type LegacyResourceQuery = {
+	include?: string | string[];
+	[key: string]: Value | undefined;
+};
+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 @warp-drive/legacy/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;
+}
+export declare function resourceIsFullyDeleted(instanceCache: InstanceCache, identifier: ResourceKey): boolean;
+/**
+A `RecordReference` is a low-level API that allows users and
+addon authors to perform meta-operations on a record.
+
+@hideconstructor
+@public
+*/
+export declare class RecordReference {
+	constructor(store: Store, identifier: ResourceKey);
+	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 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 The identifier of the record.
+	*/
+	identifier(): ResourceKey;
+	/**
+	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
+	*/
+	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 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 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 the record for this RecordReference
+	*/
+	reload(): Promise<unknown>;
+}
+export declare function getShimClass<T>(store: Store, modelName: T extends TypedRecordInstance ? TypeFromInstance<T> : string): ShimModelClass<T>;
+export declare 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;
+}