@warp-drive/core 5.6.0-alpha.15 → 5.6.0-alpha.18

package/declarations/build-config/babel-macros.d.ts

@@ -1,2 +1 @@
-export { macros } from '@warp-drive/build-config/babel-macros';
-//# sourceMappingURL=babel-macros.d.ts.map
+export { macros } from "@warp-drive/build-config/babel-macros";

package/declarations/build-config/canary-features.d.ts

@@ -1,2 +1 @@
-export * from '@warp-drive/build-config/canary-features';
-//# sourceMappingURL=canary-features.d.ts.map
+export * from "@warp-drive/build-config/canary-features";

package/declarations/build-config/debugging.d.ts

@@ -1,2 +1 @@
-export * from '@warp-drive/build-config/debugging';
-//# sourceMappingURL=debugging.d.ts.map
+export * from "@warp-drive/build-config/debugging";

package/declarations/build-config/deprecations.d.ts

@@ -1,2 +1 @@
-export * from '@warp-drive/build-config/deprecations';
-//# sourceMappingURL=deprecations.d.ts.map
+export * from "@warp-drive/build-config/deprecations";

package/declarations/build-config/env.d.ts

@@ -1,2 +1 @@
-export { DEBUG, PRODUCTION, IS_CI, IS_RECORDING, SHOULD_RECORD, TESTING } from '@warp-drive/build-config/env';
-//# sourceMappingURL=env.d.ts.map
+export { DEBUG, PRODUCTION, IS_CI, IS_RECORDING, SHOULD_RECORD, TESTING } from "@warp-drive/build-config/env";

package/declarations/build-config/macros.d.ts

@@ -1,2 +1 @@
-export { assert } from '@warp-drive/build-config/macros';
-//# sourceMappingURL=macros.d.ts.map
+export { assert } from "@warp-drive/build-config/macros";

package/declarations/build-config.d.ts

@@ -1,2 +1 @@
-export { setConfig } from '@warp-drive/build-config';
-//# sourceMappingURL=build-config.d.ts.map
+export { setConfig } from "@warp-drive/build-config";

package/declarations/configure.d.ts

@@ -1,8 +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';
-//# sourceMappingURL=configure.d.ts.map
+* 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/declarations/graph/-private/-diff.d.ts

@@ -1,33 +1,32 @@
-import type { StableRecordIdentifier } from '../../types/identifier.ts';
-import type { CollectionEdge } from './edges/collection.ts';
-import type { ResourceEdge } from './edges/resource.ts';
-import type { Graph } from './graph.ts';
+import type { StableRecordIdentifier } 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;
+	add: Set<T>;
+	del: Set<T>;
+	finalState: T[];
+	finalSet: Set<T>;
+	changed: boolean;
+	remoteOrderChanged: boolean;
 };
 export declare function diffCollection(finalState: StableRecordIdentifier[], relationship: CollectionEdge, onAdd: (v: StableRecordIdentifier) => void, onDel: (v: StableRecordIdentifier) => void): Diff<StableRecordIdentifier>;
 export declare function computeLocalState(storage: CollectionEdge): StableRecordIdentifier[];
 /**
- * A function which attempts to add a value to the local state of a collection
- * relationship, and returns true if the value was added, or false if it was
- * already present.
- *
- * It will not generate a notification, will not update the relationships to dirty,
- * and will not update the inverse relationships, making it suitable for use as
- * an internal util to perform the just the addition to a specific side of a
- * relationship.
- *
- * @internal
- */
+* A function which attempts to add a value to the local state of a collection
+* relationship, and returns true if the value was added, or false if it was
+* already present.
+*
+* It will not generate a notification, will not update the relationships to dirty,
+* and will not update the inverse relationships, making it suitable for use as
+* an internal util to perform the just the addition to a specific side of a
+* relationship.
+*
+* @internal
+*/
 export declare function _add(graph: Graph, record: StableRecordIdentifier, relationship: CollectionEdge, value: StableRecordIdentifier, index: number | null, isRemote: boolean): boolean;
 export declare function _remove(graph: Graph, record: StableRecordIdentifier, relationship: CollectionEdge, value: StableRecordIdentifier, index: number | null, isRemote: boolean): boolean;
 export declare function _removeLocal(relationship: CollectionEdge, value: StableRecordIdentifier): boolean;
 export declare function _removeRemote(relationship: CollectionEdge, value: StableRecordIdentifier): boolean;
 export declare function rollbackRelationship(graph: Graph, identifier: StableRecordIdentifier, field: string, relationship: CollectionEdge | ResourceEdge): void;
 export {};
-//# sourceMappingURL=-diff.d.ts.map

package/declarations/graph/-private/-edge-definition.d.ts

@@ -1,149 +1,148 @@
-import type { StableRecordIdentifier } from '../../types.ts';
-import type { CollectionField, FieldSchema, LegacyBelongsToField, LegacyHasManyField, ResourceField } from '../../types/schema/fields.ts';
-import type { Graph } from './graph.ts';
+import type { StableRecordIdentifier } 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 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,
- * }
- * ```
- *
- *
- * @class UpgradedMeta
- * @internal
- */
+*
+* 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,
+* }
+* ```
+*
+*
+* @class UpgradedMeta
+* @internal
+*/
 export interface UpgradedMeta {
-    kind: 'implicit' | RelationshipFieldKind;
-    /**
-     * The field name on `this` record
-     *
-     * @internal
-     */
-    key: string;
-    /**
-     * The `type` of the related record
-     *
-     * @internal
-     */
-    type: string;
-    isAsync: boolean;
-    isImplicit: boolean;
-    isCollection: boolean;
-    isPolymorphic: boolean;
-    resetOnRemoteUpdate: boolean;
-    isLinksMode: boolean;
-    inverseKind: 'implicit' | RelationshipFieldKind;
-    /**
-     * The field name on the opposing record
-     * @internal
-     */
-    inverseKey: string;
-    /**
-     * The `type` of `this` record
-     * @internal
-     */
-    inverseType: string;
-    inverseIsAsync: boolean;
-    inverseIsImplicit: boolean;
-    inverseIsCollection: boolean;
-    inverseIsPolymorphic: boolean;
-    inverseIsLinksMode: boolean;
+	kind: "implicit" | RelationshipFieldKind;
+	/**
+	* The field name on `this` record
+	*
+	* @internal
+	*/
+	key: string;
+	/**
+	* The `type` of the related record
+	*
+	* @internal
+	*/
+	type: string;
+	isAsync: boolean;
+	isImplicit: boolean;
+	isCollection: boolean;
+	isPolymorphic: boolean;
+	resetOnRemoteUpdate: boolean;
+	isLinksMode: boolean;
+	inverseKind: "implicit" | RelationshipFieldKind;
+	/**
+	* The field name on the opposing record
+	* @internal
+	*/
+	inverseKey: string;
+	/**
+	* The `type` of `this` record
+	* @internal
+	*/
+	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.
-     *
-     * @internal
-     */
-    isSelfReferential: boolean;
-    /**
-     * If this is a reflexive relationship, this is true
-     * if the relationship also points back at the same
-     * field.
-     *
-     * @internal
-     */
-    isReflexive: boolean;
+	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.
+	*
+	* @internal
+	*/
+	isSelfReferential: boolean;
+	/**
+	* If this is a reflexive relationship, this is true
+	* if the relationship also points back at the same
+	* field.
+	*
+	* @internal
+	*/
+	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, identifier: StableRecordIdentifier, propertyName: string, isImplicit?: boolean): EdgeDefinition | null;
-//# sourceMappingURL=-edge-definition.d.ts.map

package/declarations/graph/-private/-state.d.ts

@@ -1,10 +1,96 @@
 export interface RelationshipState {
-    hasReceivedData: boolean;
-    isEmpty: boolean;
-    isStale: boolean;
-    hasFailedLoadAttempt: boolean;
-    shouldForceReload: boolean;
-    hasDematerializedInverse: boolean;
+	/*
+	This flag indicates whether we should consider the content
+	of this relationship "known".
+	
+	If we have no relationship knowledge, and the relationship
+	is `async`, we will attempt to fetch the relationship on
+	access if it is also stale.
+	
+	Snapshot uses this to tell the difference between unknown
+	(`undefined`) or empty (`null`). The reason for this is that
+	we wouldn't want to serialize  unknown relationships as `null`
+	as that might overwrite remote state.
+	
+	All relationships for a newly created (`store.createRecord()`) are
+	considered known (`hasReceivedData === true`).
+	
+	true when
+	=> we receive a push with either new data or explicit empty (`[]` or `null`)
+	=> the relationship is a belongsTo and we have received data from
+	the other side.
+	
+	false when
+	=> we have received no signal about what data belongs in this relationship
+	=> the relationship is a hasMany and we have only received data from
+	the other side.
+	*/
+	hasReceivedData: boolean;
+	/*
+	Flag that indicates whether an empty relationship is explicitly empty
+	(signaled by push giving us an empty array or null relationship)
+	e.g. an API response has told us that this relationship is empty.
+	
+	Thus far, it does not appear that we actually need this flag; however,
+	@runspired has found it invaluable when debugging relationship tests
+	to determine whether (and why if so) we are in an incorrect state.
+	
+	true when
+	=> we receive a push with explicit empty (`[]` or `null`)
+	=> we have received no signal about what data belongs in this relationship
+	=> on initial create (as no signal is known yet)
+	
+	false at all other times
+	*/
+	isEmpty: boolean;
+	/*
+	This flag indicates whether we should
+	re-fetch the relationship the next time
+	it is accessed.
+	
+	The difference between this flag and `shouldForceReload`
+	is in how we treat the presence of partially missing data:
+	- for a forced reload, we will reload the link or EVERY record
+	- for a stale reload, we will reload the link (if present) else only MISSING records
+	
+	Ideally these flags could be merged, but because we don't give the
+	request layer the option of deciding how to resolve the data being queried
+	we are forced to differentiate for now.
+	
+	It is also possible for a relationship to remain stale after a forced reload; however,
+	in this case `state.hasFailedLoadAttempt` ought to be `true`.
+	
+	false when
+	=> cache.isNew(identifier) on initial setup
+	=> a previously triggered request has resolved
+	=> we get relationship data via push
+	
+	true when
+	=> !cache.isNew(identifier) on initial setup
+	=> an inverse has been unloaded
+	=> we get a new link for the relationship
+	
+	TODO @runspired unskip the acceptance tests and fix these flags
+	*/
+	isStale: boolean;
+	hasFailedLoadAttempt: boolean;
+	/*
+	This flag forces fetch. `true` for a single request once `reload()`
+	has been called `false` at all other times.
+	*/
+	shouldForceReload: boolean;
+	/*
+	This flag indicates whether we should
+	**partially** re-fetch the relationship the
+	next time it is accessed.
+	
+	false when
+	=> initial setup
+	=> a previously triggered request has resolved
+	
+	true when
+	=> an inverse has been unloaded
+	*/
+	hasDematerializedInverse: boolean;
 }
 export declare function createState(): RelationshipState;
-//# sourceMappingURL=-state.d.ts.map

package/declarations/graph/-private/-utils.d.ts

@@ -1,16 +1,16 @@
-import type { Store } from '../../store/-private.ts';
-import type { CacheCapabilitiesManager } from '../../types.ts';
-import type { UpdateResourceRelationshipOperation } from '../../types/cache/operations.ts';
-import type { UpdateRelationshipOperation } from '../../types/graph.ts';
-import type { StableRecordIdentifier } from '../../types/identifier.ts';
-import type { ResourceIdentifierObject } from '../../types/spec/json-api-raw.ts';
-import type { UpgradedMeta } from './-edge-definition.ts';
-import type { CollectionEdge } from './edges/collection.ts';
-import type { ImplicitEdge } from './edges/implicit.ts';
-import type { ResourceEdge } from './edges/resource.ts';
-import type { Graph, GraphEdge } from './graph.ts';
+import type { Store } from "../../store/-private.js";
+import type { CacheCapabilitiesManager } from "../../types.js";
+import type { UpdateResourceRelationshipOperation } from "../../types/cache/operations.js";
+import type { UpdateRelationshipOperation } from "../../types/graph.js";
+import type { StableRecordIdentifier } from "../../types/identifier.js";
+import type { ResourceIdentifierObject } from "../../types/spec/json-api-raw.js";
+import type { UpgradedMeta } from "./-edge-definition.js";
+import type { CollectionEdge } from "./edges/collection.js";
+import type { ImplicitEdge } from "./edges/implicit.js";
+import type { ResourceEdge } from "./edges/resource.js";
+import type { Graph, GraphEdge } from "./graph.js";
 export declare function getStore(wrapper: CacheCapabilitiesManager | {
-    _store: Store;
+	_store: Store;
 }): Store;
 export declare function expandingGet<T>(cache: Record<string, Record<string, T>>, key1: string, key2: string): T | undefined;
 export declare function expandingSet<T>(cache: Record<string, Record<string, T>>, key1: string, key2: string, value: T): void;
@@ -20,7 +20,12 @@ export declare function isBelongsTo(relationship: GraphEdge): relationship is Re
 export declare function isImplicit(relationship: GraphEdge): relationship is ImplicitEdge;
 export declare function isHasMany(relationship: GraphEdge): relationship is CollectionEdge;
 export declare function forAllRelatedIdentifiers(rel: GraphEdge, cb: (identifier: StableRecordIdentifier) => void): void;
+/*
+Removes the given identifier from BOTH remote AND local state.
+
+This method is useful when either a deletion or a rollback on a new record
+needs to entirely purge itself from an inverse relationship.
+*/
 export declare function removeIdentifierCompletelyFromRelationship(graph: Graph, relationship: GraphEdge, value: StableRecordIdentifier, silenceNotifications?: boolean): void;
 export declare function notifyChange(graph: Graph, relationship: CollectionEdge | ResourceEdge): void;
 export declare function assertRelationshipData(store: Store, identifier: StableRecordIdentifier, data: ResourceIdentifierObject, meta: UpgradedMeta): void;
-//# sourceMappingURL=-utils.d.ts.map

package/declarations/graph/-private/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: Coercable): string | null;
 export declare function ensureStringId(id: Coercable): string;
 export {};
-//# sourceMappingURL=coerce-id.d.ts.map

package/declarations/graph/-private/debug/assert-polymorphic-type.d.ts

@@ -1,7 +1,18 @@
-import type { CacheCapabilitiesManager } from '../../../types.ts';
-import type { StableRecordIdentifier } from '../../../types/identifier.ts';
-import { type UpgradedMeta } from '../-edge-definition.ts';
+import type { CacheCapabilitiesManager } from "../../../types.js";
+import type { StableRecordIdentifier } from "../../../types/identifier.js";
+import { type UpgradedMeta } from "../-edge-definition.js";
+/*
+Assert that `addedRecord` has a valid type so it can be added to the
+relationship of the `record`.
+
+The assert basically checks if the `addedRecord` can be added to the
+relationship (specified via `relationshipMeta`) of the `record`.
+
+This utility should only be used internally, as both record parameters must
+be stable record identifiers and the `relationshipMeta` needs to be the meta
+information about the relationship, retrieved via
+`record.relationshipFor(key)`.
+*/
 declare let assertPolymorphicType: (parentIdentifier: StableRecordIdentifier, parentDefinition: UpgradedMeta, addedIdentifier: StableRecordIdentifier, store: CacheCapabilitiesManager) => void;
 declare let assertInheritedSchema: (definition: UpgradedMeta, type: string) => void;
 export { assertPolymorphicType, assertInheritedSchema };
-//# sourceMappingURL=assert-polymorphic-type.d.ts.map