@warp-drive/core 5.8.0-alpha.30 → 5.8.0-alpha.34

package/dist/unpkg/prod/declarations/graph/-private/operations/update-relationship.d.ts

@@ -0,0 +1,9 @@
+import type { Store } from "../../../index.js";
+import type { ResourceKey } from "../../../types.js";
+import type { UpdateResourceRelationshipOperation } from "../../../types/cache/operations.js";
+import type { UpdateRelationshipOperation } from "../../../types/graph.js";
+import type { ExistingResourceIdentifierObject, NewResourceIdentifierObject } from "../../../types/spec/json-api-raw.js";
+import type { Graph } from "../graph.js";
+type CacheKeyManager = Store["cacheKeyManager"];
+export default function updateRelationshipOperation(graph: Graph, op: UpdateRelationshipOperation | UpdateResourceRelationshipOperation): void;
+export declare function upgradeIdentifiers(arr: (ExistingResourceIdentifierObject | NewResourceIdentifierObject | ResourceKey)[], cache: CacheKeyManager): ResourceKey[];

package/dist/unpkg/prod/declarations/graph/-private.d.ts

@@ -0,0 +1,13 @@
+import type { Store } from "../index.js";
+import type { CacheCapabilitiesManager } from "../types.js";
+import { Graph } from "./-private/graph.js";
+export { isBelongsTo } from "./-private/-utils.js";
+export type { CollectionEdge } from "./-private/edges/collection.js";
+export type { ResourceEdge } from "./-private/edges/resource.js";
+export type { ImplicitEdge } from "./-private/edges/implicit.js";
+export type { GraphEdge } from "./-private/graph.js";
+export type { UpgradedMeta } from "./-private/-edge-definition.js";
+export type { Graph };
+export declare function peekGraph(store: CacheCapabilitiesManager | Store): Graph | undefined;
+export type peekGraph = typeof peekGraph;
+export declare function graphFor(store: CacheCapabilitiesManager | Store): Graph;

package/dist/unpkg/prod/declarations/index.d.ts

@@ -0,0 +1,100 @@
+/**
+* @module
+* @mergeModuleWith <project>
+*/
+import type { CAUTION_MEGA_DANGER_ZONE_Extension } from "./reactive.js";
+import type { ReactiveDocument } from "./reactive/-private/document.js";
+import type { Handler } from "./request.js";
+import { Fetch } from "./request/-private/fetch.js";
+import { RequestManager } from "./request/-private/manager.js";
+import { CacheHandler, type CachePolicy, Store } from "./store/-private.js";
+import { recordIdentifierFor } from "./store/-private.js";
+import type { CacheCapabilitiesManager } from "./types.js";
+import type { Cache } from "./types/cache.js";
+import type { Derivation, HashFn, Transformation } from "./types/schema/concepts.js";
+import type { ObjectSchema, PolarisResourceSchema, Trait } from "./types/schema/fields.js";
+export { recordIdentifierFor, recordIdentifierFor as cacheKeyFor };
+export { Fetch, RequestManager };
+export { Store, CacheHandler, type CachePolicy };
+export { type StoreRequestContext, type StoreRequestInput, storeFor } from "./store/-private.js";
+/**
+* @deprecated use {@link ReactiveDocument} instead
+*/
+export type Document<T> = ReactiveDocument<T>;
+export type { DocumentCacheOperation, CacheOperation, NotificationType } from "./store/-private/managers/notification-manager.js";
+export { setIdentifierGenerationMethod, setIdentifierUpdateMethod, setIdentifierForgetMethod, setIdentifierResetMethod, setKeyInfoForResource } from "./store/-private/managers/cache-key-manager.js";
+/**
+* Options for setting up a Store instance with `useRecommendedStore`.
+*/
+export interface StoreSetupOptions<T extends Cache = Cache> {
+	/**
+	* The Cache implementation to use
+	*/
+	cache: new (capabilities: CacheCapabilitiesManager) => T;
+	/**
+	* The Cache policy to use.
+	*
+	* Defaults to {@link DefaultCachePolicy} configured to
+	* respect `Expires`, `X-WarpDrive-Expires`, and `Cache-Control` headers
+	* with a fallback to 30s soft expiration and 15m hard expiration.
+	*/
+	policy?: CachePolicy;
+	/**
+	* The request handlers to use. {@link Fetch} will automatically
+	* be added to the end of the handler chain and {@link CacheHandler}
+	* will automatically be added as the cache handler.
+	*/
+	handlers?: Handler[];
+	/**
+	* Schemas describing the structure of your resource data.
+	*
+	* See {@link PolarisResourceSchema,} and {@link ObjectSchema} for more information.
+	*/
+	schemas?: Array<PolarisResourceSchema | ObjectSchema>;
+	/**
+	* {@link Trait | Traits} to use with {@link PolarisResourceSchema, | Resource Schemas}
+	*/
+	traits?: Trait[];
+	/**
+	* {@link Derivation | Derivations} to use for derived fields.
+	*/
+	derivations?: Derivation[];
+	/**
+	* {@link Transformation | Transformations} to use for transforming fields.
+	*/
+	transformations?: Transformation[];
+	/**
+	* {@link HashFn | Hash Functions} to use for embedded object identity and polymorphic type calculations
+	*/
+	hashFns?: HashFn[];
+	/**
+	* {@link CAUTION_MEGA_DANGER_ZONE_Extension | Extensions} to use with resources, objects and arrays
+	* to provide custom behaviors and capabilities that are not described by Schema.
+	*
+	* This feature should only be used during a transition period to support migrating towards
+	* schemas from existing Model and ModelFragments implementations.
+	*/
+	CAUTION_MEGA_DANGER_ZONE_extensions?: CAUTION_MEGA_DANGER_ZONE_Extension[];
+}
+export declare class ConfiguredStore<T extends {
+	cache: Cache;
+}> extends Store {
+	createCache(capabilities: CacheCapabilitiesManager): T["cache"];
+}
+/**
+* Creates a configured Store class with recommended defaults
+* for schema handling, reactivity, caching, and request management.
+*
+* ```ts
+* import { useRecommendedStore } from '@warp-drive/core';
+* import { JSONAPICache } from '@warp-drive/json-api';
+*
+* export const Store = useRecommendedStore({
+*   cache: JSONAPICache,
+*   schemas: [],
+* });
+* ```
+*/
+export declare function useRecommendedStore<T extends Cache>(options: StoreSetupOptions<T>, StoreKlass?: typeof Store): typeof ConfiguredStore<{
+	cache: T;
+}>;

package/dist/unpkg/prod/declarations/reactive/-private/default-mode.d.ts

@@ -0,0 +1,73 @@
+import type { Store } from "../../store/-private.js";
+import type { SignalStore } from "../../store/-private/new-core-tmp/reactivity/internal.js";
+import type { ResourceKey } from "../../types.js";
+import type { FieldSchema, HashField, IdentityField, SchemaArrayField, SchemaObjectField } from "../../types/schema/fields.js";
+import type { ReactiveResource } from "./record.js";
+export type PathLike = string | symbol | Array<string | symbol>;
+export type ModeName = "polaris" | "legacy";
+export interface ModeInfo {
+	name: ModeName;
+	legacy: boolean;
+	editable: boolean;
+}
+export interface BaseContext {
+	store: Store;
+	resourceKey: ResourceKey;
+	modeName: ModeName;
+	legacy: boolean;
+	editable: boolean;
+}
+export interface ResourceContext extends BaseContext {
+	path: null;
+	field: null;
+	value: null;
+}
+export interface ObjectContext extends BaseContext {
+	path: string[];
+	field: SchemaObjectField | SchemaArrayField;
+	value: string;
+}
+export interface KindContext<T extends FieldSchema | IdentityField | HashField> extends BaseContext {
+	path: string[];
+	field: T;
+	value: unknown;
+	record: ReactiveResource;
+	signals: SignalStore;
+}
+export interface KindImpl<T extends FieldSchema | IdentityField | HashField> {
+	/**
+	* A function which produces the value for the field when invoked.
+	*/
+	get: (context: KindContext<T>) => unknown;
+	/**
+	* A function which updates the value for the field when invoked.
+	*
+	* This will never be invoked when the record is in a non-editable mode.
+	*
+	* This should assert in dev and return false if mutation is not allowed.
+	*/
+	set: (context: KindContext<T>) => boolean;
+	/**
+	* Whether this field is ever mutable (writable). This should be
+	* if there is ever a scenario in which the field can be written
+	* and false only if the field can never be written to.
+	*/
+	mutable: boolean;
+	/**
+	* Whether this field's of this kind should be included in the
+	* enumerated (iterable) keys of the record/object instance.
+	*
+	* This should generally be true except for fields that are not
+	* producing a value backed by the cache. For instance, locals
+	* should not be enumerable, as their value is not tied to the
+	* cache at all.
+	*/
+	enumerable: boolean;
+	/**
+	*
+	*/
+	serializable: boolean;
+}
+type Mode = { [Field in FieldSchema | IdentityField | HashField as Field["kind"]] : KindImpl<Field> };
+export declare const DefaultMode: Mode;
+export {};

package/dist/unpkg/prod/declarations/reactive/-private/document.d.ts

@@ -0,0 +1,142 @@
+import type { Store } from "../../store/-private/store-service.js";
+import type { RequestKey } from "../../types/identifier.js";
+import type { ImmutableRequestInfo, RequestInfo } from "../../types/request.js";
+import type { ResourceDocument } from "../../types/spec/document.js";
+import type { Meta, PaginationLinks } from "../../types/spec/json-api-raw.js";
+export interface ReactiveDocumentBase<T> {
+	/**
+	* The links object for this document, if any
+	*
+	* e.g.
+	*
+	* ```ts
+	* {
+	*   self: '/articles?page[number]=3',
+	* }
+	* ```
+	*
+	* @public
+	*/
+	readonly links?: PaginationLinks;
+	/**
+	* The meta object for this document, if any
+	*
+	* @public
+	*/
+	readonly meta?: Meta;
+	/**
+	* The RequestKey associated with this document, if any
+	*
+	* @public
+	*/
+	readonly identifier: RequestKey | null;
+	/**
+	* Fetches the related link for this document, returning a promise that resolves
+	* with the document when the request completes. If no related link is present,
+	* will fallback to the self link if present
+	*
+	* @public
+	*/
+	fetch(options?: RequestInfo<ReactiveDocument<T>>): Promise<ReactiveDocument<T>>;
+	/**
+	* Fetches the next link for this document, returning a promise that resolves
+	* with the new document when the request completes, or null  if there is no
+	* next link.
+	*
+	* @public
+	*/
+	next(options?: RequestInfo<ReactiveDocument<T>>): Promise<ReactiveDocument<T> | null>;
+	/**
+	* Fetches the prev link for this document, returning a promise that resolves
+	* with the new document when the request completes, or null if there is no
+	* prev link.
+	*
+	* @public
+	*/
+	prev(options: RequestInfo<ReactiveDocument<T>>): Promise<ReactiveDocument<T> | null>;
+	/**
+	* Fetches the first link for this document, returning a promise that resolves
+	* with the new document when the request completes, or null if there is no
+	* first link.
+	*
+	* @public
+	*/
+	first(options: RequestInfo<ReactiveDocument<T>>): Promise<ReactiveDocument<T> | null>;
+	/**
+	* Fetches the last link for this document, returning a promise that resolves
+	* with the new document when the request completes, or null if there is no
+	* last link.
+	*
+	* @public
+	*/
+	last(options: RequestInfo<ReactiveDocument<T>>): Promise<ReactiveDocument<T> | null>;
+	/**
+	* Implemented for `JSON.stringify` support.
+	*
+	* Returns the JSON representation of the document wrapper.
+	*
+	* This is a shallow serialization, it does not deeply serialize
+	* the document's contents, leaving that to the individual record
+	* instances to determine how to do, if at all.
+	*
+	* @public
+	* @return
+	*/
+	toJSON(): object;
+}
+export interface ReactiveErrorDocument<T> extends ReactiveDocumentBase<T> {
+	/**
+	* The primary data for this document, if any.
+	*
+	* If this document has no primary data (e.g. because it is an error document)
+	* this property will be `undefined`.
+	*
+	* For collections this will be an array of record instances,
+	* for single resource requests it will be a single record instance or null.
+	*
+	* @public
+	*/
+	readonly data?: undefined;
+	/**
+	* The errors returned by the API for this request, if any
+	*
+	* @public
+	*/
+	readonly errors: object[];
+}
+export interface ReactiveDataDocument<T> extends ReactiveDocumentBase<T> {
+	/**
+	* The primary data for this document, if any.
+	*
+	* If this document has no primary data (e.g. because it is an error document)
+	* this property will be `undefined`.
+	*
+	* For collections this will be an array of record instances,
+	* for single resource requests it will be a single record instance or null.
+	*
+	* @public
+	*/
+	readonly data: T;
+	/**
+	* The errors returned by the API for this request, if any
+	*
+	* @public
+	*/
+	readonly errors?: undefined;
+}
+/**
+* A Document is a class that wraps the response content from a request to the API
+* returned by `Cache.put` or `Cache.peek`, converting ResourceKeys into
+* ReactiveResource instances.
+*
+* It is not directly instantiated by the user, and its properties should not
+* be directly modified. Whether individual properties are mutable or not is
+* determined by the record instance itself.
+*
+* @public
+*/
+export type ReactiveDocument<T> = ReactiveDataDocument<T> | ReactiveErrorDocument<T>;
+export declare function createReactiveDocument<T>(store: Store, cacheKey: RequestKey | null, localCache: {
+	document: ResourceDocument;
+	request: ImmutableRequestInfo;
+} | null): ReactiveDocument<T>;

package/dist/unpkg/prod/declarations/reactive/-private/fields/extension.d.ts

@@ -0,0 +1,8 @@
+import type { SignalStore, WarpDriveSignal } from "../../../store/-private/new-core-tmp/reactivity/internal.js";
+import type { ExtensionDef } from "../schema.js";
+export type ProxiedMethod = (...args: unknown[]) => unknown;
+export declare function expectNever(value: never): void;
+export declare function isExtensionProp(extensions: Map<string | symbol, ExtensionDef> | null, prop: string | number | symbol): prop is string | symbol;
+export declare function performObjectExtensionGet(receiver: object, extensions: Map<string | symbol, ExtensionDef>, signals: SignalStore, prop: string | symbol): unknown;
+export declare function performExtensionSet(receiver: object, extensions: Map<string | symbol, ExtensionDef>, signals: SignalStore, prop: string | symbol, value: unknown): boolean;
+export declare function performArrayExtensionGet(receiver: object, extensions: Map<string | symbol, ExtensionDef>, signals: SignalStore, prop: string | symbol, _SIGNAL: WarpDriveSignal, boundFns: Map<string | symbol | number, ProxiedMethod>, transaction: (v: boolean) => void): unknown;

package/dist/unpkg/prod/declarations/reactive/-private/fields/get-field-key.d.ts

@@ -0,0 +1,8 @@
+import type { CacheableFieldSchema, FieldSchema, HashField, IdentityField } from "../../../types/schema/fields.js";
+type InvalidKind = "alias" | "derived" | "@local";
+export declare function isInvalidKind(kind: string): kind is InvalidKind;
+export declare function isNonIdentityCacheableField(field: FieldSchema | IdentityField | HashField): field is Exclude<CacheableFieldSchema, IdentityField>;
+export declare function getFieldCacheKeyStrict(field: CacheableFieldSchema): string;
+export declare function getFieldCacheKey(field: FieldSchema | IdentityField | HashField): string | null;
+export declare function assertIsCacheField(field: FieldSchema | IdentityField): asserts field is CacheableFieldSchema;
+export {};

package/dist/unpkg/prod/declarations/reactive/-private/fields/managed-array.d.ts

@@ -0,0 +1,18 @@
+import type { WarpDriveSignal } from "../../../store/-private.js";
+import { ARRAY_SIGNAL } from "../../../store/-private.js";
+import type { ResourceKey } from "../../../types/identifier.js";
+import type { ArrayField, SchemaArrayField } from "../../../types/schema/fields.js";
+import type { KindContext } from "../default-mode.js";
+import { ReactiveResource } from "../record.js";
+import { Context, SOURCE } from "../symbols.js";
+export interface ManagedArray extends Omit<Array<unknown>, "[]"> {
+	[SOURCE]: unknown[];
+	identifier: ResourceKey;
+	path: string | string[];
+	owner: ReactiveResource;
+	[ARRAY_SIGNAL]: WarpDriveSignal;
+	[Context]: KindContext<SchemaArrayField | ArrayField>;
+}
+export declare class ManagedArray {
+	constructor(context: KindContext<SchemaArrayField | ArrayField>, owner: ReactiveResource, data: unknown[]);
+}

package/dist/unpkg/prod/declarations/reactive/-private/fields/managed-object.d.ts

@@ -0,0 +1,17 @@
+import { OBJECT_SIGNAL, type WarpDriveSignal } from "../../../store/-private.js";
+import type { ObjectField, SchemaObjectField } from "../../../types/schema/fields.js";
+import type { KindContext } from "../default-mode.js";
+import type { ReactiveResource } from "../record.js";
+import { Context, SOURCE } from "../symbols.js";
+export declare function notifyObject(obj: ManagedObject): void;
+export interface ManagedObject {
+	[SOURCE]: object;
+	[Context]: KindContext<ObjectField>;
+	[OBJECT_SIGNAL]: WarpDriveSignal;
+}
+export declare class ManagedObject {
+	constructor(context: KindContext<ObjectField>);
+}
+export declare const ManagedObjectMap: Map<ReactiveResource, Map<string, ManagedObject | ReactiveResource>>;
+export declare function peekManagedObject(record: ReactiveResource, field: ObjectField): ManagedObject | undefined;
+export declare function peekManagedObject(record: ReactiveResource, field: SchemaObjectField): ReactiveResource | undefined;

package/dist/unpkg/prod/declarations/reactive/-private/fields/many-array-manager.d.ts

@@ -0,0 +1,19 @@
+import type { Store } from "../../../index.js";
+import type { RelatedCollection as ManyArray } from "../../../store/-private.js";
+import type { LocalRelationshipOperation } from "../../../types/graph.js";
+import type { ResourceKey } from "../../../types/identifier.js";
+import type { ReactiveResource } from "../record.js";
+export interface FindHasManyOptions {
+	reload?: boolean;
+	backgroundReload?: boolean;
+}
+export declare class ManyArrayManager {
+	record: ReactiveResource;
+	store: Store;
+	identifier: ResourceKey;
+	editable: boolean;
+	constructor(record: ReactiveResource, editable: boolean);
+	_syncArray(array: ManyArray): void;
+	reloadHasMany<T>(key: string, options?: FindHasManyOptions): Promise<ManyArray<T>>;
+	mutate(mutation: LocalRelationshipOperation): void;
+}

package/dist/unpkg/prod/declarations/reactive/-private/hooks.d.ts

@@ -0,0 +1,5 @@
+import type { Store } from "../../index.js";
+import type { ResourceKey } from "../../types.js";
+import { ReactiveResource } from "./record.js";
+export declare function instantiateRecord(store: Store, identifier: ResourceKey, createArgs?: Record<string, unknown>): ReactiveResource;
+export declare function teardownRecord(record: unknown): void;

package/dist/unpkg/prod/declarations/reactive/-private/kind/alias-field.d.ts

@@ -0,0 +1,4 @@
+import type { LegacyAliasField, ObjectAliasField, PolarisAliasField } from "../../../types/schema/fields.js";
+import type { KindContext } from "../default-mode.js";
+export declare function getAliasField(context: KindContext<LegacyAliasField | ObjectAliasField | PolarisAliasField>): unknown;
+export declare function setAliasField(context: KindContext<LegacyAliasField | ObjectAliasField | PolarisAliasField>): boolean;

package/dist/unpkg/prod/declarations/reactive/-private/kind/array-field.d.ts

@@ -0,0 +1,4 @@
+import type { ArrayField, SchemaArrayField } from "../../../types/schema/fields.js";
+import type { KindContext } from "../default-mode.js";
+export declare function getArrayField(context: KindContext<ArrayField | SchemaArrayField>): unknown;
+export declare function setArrayField(context: KindContext<ArrayField>): boolean;

package/dist/unpkg/prod/declarations/reactive/-private/kind/attribute-field.d.ts

@@ -0,0 +1,4 @@
+import type { LegacyAttributeField } from "../../../types/schema/fields.js";
+import type { KindContext } from "../default-mode.js";
+export declare function getAttributeField(context: KindContext<LegacyAttributeField>): unknown;
+export declare function setAttributeField(context: KindContext<LegacyAttributeField>): boolean;

package/dist/unpkg/prod/declarations/reactive/-private/kind/belongs-to-field.d.ts

@@ -0,0 +1,4 @@
+import type { LegacyBelongsToField } from "../../../types/schema/fields.js";
+import type { KindContext } from "../default-mode.js";
+export declare function getBelongsToField(context: KindContext<LegacyBelongsToField>): unknown;
+export declare function setBelongsToField(context: KindContext<LegacyBelongsToField>): boolean;

package/dist/unpkg/prod/declarations/reactive/-private/kind/collection-field.d.ts

@@ -0,0 +1,4 @@
+import type { CollectionField } from "../../../types/schema/fields.js";
+import type { KindContext } from "../default-mode.js";
+export declare function getCollectionField(context: KindContext<CollectionField>): unknown;
+export declare function setCollectionField(context: KindContext<CollectionField>): boolean;

package/dist/unpkg/prod/declarations/reactive/-private/kind/derived-field.d.ts

@@ -0,0 +1,4 @@
+import type { DerivedField } from "../../../types/schema/fields.js";
+import type { KindContext } from "../default-mode.js";
+export declare function getDerivedField(context: KindContext<DerivedField>): unknown;
+export declare function setDerivedField(context: KindContext<DerivedField>): boolean;

package/dist/unpkg/prod/declarations/reactive/-private/kind/generic-field.d.ts

@@ -0,0 +1,4 @@
+import type { GenericField } from "../../../types/schema/fields.js";
+import type { KindContext } from "../default-mode.js";
+export declare function getGenericField(context: KindContext<GenericField>): unknown;
+export declare function setGenericField(context: KindContext<GenericField>): boolean;

package/dist/unpkg/prod/declarations/reactive/-private/kind/has-many-field.d.ts

@@ -0,0 +1,4 @@
+import type { LegacyHasManyField } from "../../../types/schema/fields.js";
+import type { KindContext } from "../default-mode.js";
+export declare function getHasManyField(context: KindContext<LegacyHasManyField>): unknown;
+export declare function setHasManyField(context: KindContext<LegacyHasManyField>): boolean;

package/dist/unpkg/prod/declarations/reactive/-private/kind/hash-field.d.ts

@@ -0,0 +1,4 @@
+import type { HashField } from "../../../types/schema/fields.js";
+import type { KindContext } from "../default-mode.js";
+export declare function getHashField(context: KindContext<HashField>): unknown;
+export declare function setHashField(context: KindContext<HashField>): boolean;

package/dist/unpkg/prod/declarations/reactive/-private/kind/identity-field.d.ts

@@ -0,0 +1,4 @@
+import type { IdentityField } from "../../../types/schema/fields.js";
+import type { KindContext } from "../default-mode.js";
+export declare function getIdentityField(context: KindContext<IdentityField>): unknown;
+export declare function setIdentityField(context: KindContext<IdentityField>): boolean;

package/dist/unpkg/prod/declarations/reactive/-private/kind/local-field.d.ts

@@ -0,0 +1,4 @@
+import type { LocalField } from "../../../types/schema/fields.js";
+import type { KindContext } from "../default-mode.js";
+export declare function getLocalField(context: KindContext<LocalField>): unknown;
+export declare function setLocalField(context: KindContext<LocalField>): boolean;

package/dist/unpkg/prod/declarations/reactive/-private/kind/object-field.d.ts

@@ -0,0 +1,4 @@
+import type { ObjectField } from "../../../types/schema/fields.js";
+import type { KindContext } from "../default-mode.js";
+export declare function getObjectField(context: KindContext<ObjectField>): unknown;
+export declare function setObjectField(context: KindContext<ObjectField>): boolean;

package/dist/unpkg/prod/declarations/reactive/-private/kind/resource-field.d.ts

@@ -0,0 +1,4 @@
+import type { ResourceField } from "../../../types/schema/fields.js";
+import type { KindContext } from "../default-mode.js";
+export declare function getResourceField(context: KindContext<ResourceField>): unknown;
+export declare function setResourceField(context: KindContext<ResourceField>): boolean;

package/dist/unpkg/prod/declarations/reactive/-private/kind/schema-array-field.d.ts

@@ -0,0 +1,4 @@
+import type { SchemaArrayField } from "../../../types/schema/fields.js";
+import type { KindContext } from "../default-mode.js";
+export { getArrayField as getSchemaArrayField } from "./array-field.js";
+export declare function setSchemaArrayField(context: KindContext<SchemaArrayField>): boolean;

package/dist/unpkg/prod/declarations/reactive/-private/kind/schema-object-field.d.ts

@@ -0,0 +1,4 @@
+import type { SchemaObjectField } from "../../../types/schema/fields.js";
+import type { KindContext } from "../default-mode.js";
+export declare function getSchemaObjectField(context: KindContext<SchemaObjectField>): unknown;
+export declare function setSchemaObjectField(context: KindContext<SchemaObjectField>): boolean;

package/dist/unpkg/prod/declarations/reactive/-private/record.d.ts

@@ -0,0 +1,83 @@
+import type { ObjectContext, ResourceContext } from "./default-mode.js";
+import { Checkout, Context } from "./symbols.js";
+export interface ReactiveResource {
+	/**
+	* Create an editable copy of the record
+	*
+	* ReactiveResource instances are not editable by default. This method creates an editable copy of the record. To use,
+	* import the `Checkout` symbol from `@warp-drive/core/reactive` and call it on the record.
+	*
+	* ```ts
+	* import { Checkout } from '@warp-drive/core/reactive';
+	*
+	* const record = store.peekRecord('user', '1');
+	* const editableRecord = await record[Checkout]();
+	* ```
+	*
+	* @returns a promise that resolves to the editable record
+	* @throws if the record is already editable or if the record is embedded
+	* @private
+	*/
+	[Checkout]<T>(): Promise<T>;
+}
+/**
+* @private
+*/
+export interface PrivateReactiveResource extends ReactiveResource {
+	/**
+	* @private
+	*/
+	[Context]: ObjectContext | ResourceContext;
+}
+/**
+* A class that uses a the ResourceSchema for a ResourceType
+* and a ResourceKey to transform data from the cache into a rich, reactive
+* object.
+*
+* This class is not directly instantiable. To use it, you should
+* configure the store's `instantiateRecord` and `teardownRecord` hooks
+* with the matching hooks provided by this package.
+*
+* @hideconstructor
+* @public
+*/
+export declare class ReactiveResource {
+	constructor(context: ResourceContext | ObjectContext);
+}
+export declare function _CHECKOUT(record: ReactiveResource): ReactiveResource;
+/**
+* Checkout an immutable resource for editing.
+*
+* {@link ReactiveResource | ReactiveResources} are not editable by default. This method
+* creates an editable copy of the resource.
+*
+* This returns a promise which resolves with the editable
+* version of the resource.
+*
+* ```ts
+* import { checkout } from '@warp-drive/core/reactive';
+*
+* const immutable = store.peekRecord('user', '1');
+* const editable = await checkout(immutable);
+* ```
+*
+* Edits to editable resources will be automatically committed if a new
+* payload from the cache matches their existing value.
+*
+* @public
+*
+* @returns a promise that resolves to the editable resource
+* @throws if the resource is already editable or if resource is an embedded object
+*/
+export declare function checkout<T>(resource: unknown): Promise<T & ReactiveResource>;
+/**
+* Forcibly commit all local changes on an editable resource to
+* the remote (immutable) version.
+*
+* This API should only be used cautiously. Typically a better
+* approach is for either the API or a Handler to reflect saved
+* changes back to update the cache.
+*
+* @public
+*/
+export declare function commit(record: ReactiveResource): Promise<void>;