@warp-drive-mirror/core 5.9.0-alpha.2 → 5.9.0-alpha.21

package/declarations/signals/request-subscription.d.ts

@@ -1,177 +0,0 @@
-import type { RequestManager, Store, StoreRequestInput } from "../index.js";
-import type { Future } from "../request.js";
-import type { StructuredErrorDocument } from "../types/request.js";
-import type { RequestState } from "./request-state.js";
-export declare const DISPOSE: "(symbol) dispose";
-export type AutorefreshBehaviorType = "online" | "interval" | "invalid";
-export type AutorefreshBehaviorCombos = boolean | AutorefreshBehaviorType | `${AutorefreshBehaviorType},${AutorefreshBehaviorType}` | `${AutorefreshBehaviorType},${AutorefreshBehaviorType},${AutorefreshBehaviorType}`;
-/**
-* Utilities to assist in recovering from the error.
-*/
-export interface RecoveryFeatures {
-	isOnline: boolean;
-	isHidden: boolean;
-	retry: () => Promise<void>;
-}
-/** @deprecated use {@link RecoveryFeatures} */
-export type ErrorFeatures = RecoveryFeatures;
-/**
-* Utilities for keeping the request fresh
-*/
-export interface ContentFeatures<RT> {
-	isOnline: boolean;
-	isHidden: boolean;
-	isRefreshing: boolean;
-	refresh: () => Promise<void>;
-	reload: () => Promise<void>;
-	abort?: () => void;
-	latestRequest?: Future<RT>;
-}
-export interface RequestArgs<
-	RT,
-	E
-> extends SubscriptionArgs<RT, E> {
-	subscription?: RequestSubscription<RT, E>;
-	/**
-	* The store instance to use for making requests. If contexts are available,
-	* the component will default to using the `store` on the context.
-	*
-	* This is required if the store is not available via context or should be
-	* different from the store provided via context.
-	*
-	*/
-	store?: Store | RequestManager;
-}
-export interface SubscriptionArgs<
-	RT,
-	E
-> {
-	/**
-	* The request to monitor. This should be a `Future` instance returned
-	* by either the `store.request` or `store.requestManager.request` methods.
-	*
-	*/
-	request?: Future<RT> | undefined | null;
-	/**
-	* A query to use for the request. This should be an object that can be
-	* passed to `store.request`. Use this in place of `@request` if you would
-	* like the component to also initiate the request.
-	*
-	*/
-	query?: StoreRequestInput<RT> | undefined | null;
-	/**
-	* The autorefresh behavior for the request. This can be a boolean, or any
-	* combination of the following values: `'online'`, `'interval'`, `'invalid'`.
-	*
-	* - `'online'`: Refresh the request when the browser comes back online
-	* - `'interval'`: Refresh the request at a specified interval
-	* - `'invalid'`: Refresh the request when the store emits an invalidation
-	*
-	* If `true`, this is equivalent to `'online,invalid'`.
-	*
-	* Defaults to `false`.
-	*
-	*/
-	autorefresh?: AutorefreshBehaviorCombos;
-	/**
-	* The number of milliseconds to wait before refreshing the request when the
-	* browser comes back online or the network becomes available.
-	*
-	* This also controls the interval at which the request will be refreshed if
-	* the `interval` autorefresh type is enabled.
-	*
-	* Defaults to `30_000` (30 seconds).
-	*
-	*/
-	autorefreshThreshold?: number;
-	/**
-	* The behavior of the request initiated by autorefresh. This can be one of
-	* the following values:
-	*
-	* - `'refresh'`: Refresh the request in the background
-	* - `'reload'`: Force a reload of the request
-	* - `'policy'` (**default**): Let the store's configured CachePolicy decide whether to
-	*    reload, refresh, or do nothing.
-	*
-	* Defaults to `'policy'`.
-	*
-	*/
-	autorefreshBehavior?: "refresh" | "reload" | "policy";
-}
-export interface RequestComponentArgs<
-	RT,
-	E
-> extends SubscriptionArgs<RT, E> {
-	/**
-	* The store instance to use for making requests. If contexts are available,
-	* the component will default to using the `store` on the context.
-	*
-	* This is required if the store is not available via context or should be
-	* different from the store provided via context.
-	*
-	*/
-	store?: Store | RequestManager;
-}
-export interface RequestSubscription<
-	RT,
-	E
-> {
-	/**
-	* The method to call when the component this subscription is attached to
-	* unmounts.
-	*/
-	[DISPOSE](): void;
-}
-/**
-* A reactive class
-*
-* @hideconstructor
-*/
-export declare class RequestSubscription<
-	RT,
-	E
-> {
-	/**
-	* Whether the browser reports that the network is online.
-	*/
-	isOnline: boolean;
-	/**
-	* Whether the browser reports that the tab is hidden.
-	*/
-	isHidden: boolean;
-	/**
-	* Whether the component is currently refreshing the request.
-	*/
-	isRefreshing: boolean;
-	/**
-	* The Store this subscription subscribes to or the RequestManager
-	* which issues this request.
-	*/
-	store: Store | RequestManager;
-	constructor(store: Store | RequestManager, args: SubscriptionArgs<RT, E>);
-	get isIdle(): boolean;
-	get autorefreshTypes(): Set<AutorefreshBehaviorType>;
-	/**
-	* Retry the request, reloading it from the server.
-	*/
-	retry: () => Promise<void>;
-	/**
-	* Refresh the request, updating it in the background.
-	*/
-	refresh: () => Promise<void>;
-	/**
-	* features to yield to the error slot of a component
-	*/
-	get errorFeatures(): RecoveryFeatures;
-	/**
-	* features to yield to the content slot of a component
-	*/
-	get contentFeatures(): ContentFeatures<RT>;
-	get request(): Future<RT>;
-	get reqState(): RequestState<RT, StructuredErrorDocument<E>>;
-	get result(): RT;
-}
-export declare function createRequestSubscription<
-	RT,
-	E
->(store: Store | RequestManager, args: SubscriptionArgs<RT, E>): RequestSubscription<RT, E>;

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

@@ -1,56 +0,0 @@
-import type { CacheHandler as CacheHandlerType } from "../../../request.js";
-import type { ImmutableRequestInfo, RequestContext } from "../../../types/request.js";
-import type { ResourceIdentifierObject } from "../../../types/spec/json-api-raw.js";
-import type { RequestSignature } from "../../../types/symbols.js";
-import type { Store } from "../store-service.js";
-export type LooseStoreRequestInfo<RT = unknown> = Omit<ImmutableRequestInfo<RT>, "records" | "headers" | typeof RequestSignature> & {
-	records?: ResourceIdentifierObject[];
-	headers?: Headers;
-};
-export type StoreRequestInput<RT = unknown> = ImmutableRequestInfo<RT> | LooseStoreRequestInfo<RT>;
-export interface StoreRequestContext extends RequestContext {
-	request: ImmutableRequestInfo & {
-		store: Store;
-	};
-}
-/**
-* A CacheHandler that adds support for using an WarpDrive Cache with a RequestManager.
-*
-* This handler will only run when a request has supplied a `store` instance. Requests
-* issued by the store via `store.request()` will automatically have the `store` instance
-* attached to the request.
-*
-* ```ts
-* requestManager.request({
-*   store: store,
-*   url: '/api/posts',
-*   method: 'GET'
-* });
-* ```
-*
-* When this handler elects to handle a request, it will return the raw `StructuredDocument`
-* unless the request has `[EnableHydration]` set to `true`. In this case, the handler will
-* return a `Document` instance that will automatically update the UI when the cache is updated
-* in the future and will hydrate any identifiers in the StructuredDocument into Record instances.
-*
-* When issuing a request via the store, [EnableHydration] is automatically set to `true`. This
-* means that if desired you can issue requests that utilize the cache without needing to also
-* utilize Record instances if desired.
-*
-* Said differently, you could elect to issue all requests via a RequestManager, without ever using
-* the store directly, by setting [EnableHydration] to `true` and providing a store instance. Not
-* necessarily the most useful thing, but the decoupled nature of the RequestManager and incremental-feature
-* approach of WarpDrive allows for this flexibility.
-*
-* ```ts
-* import { EnableHydration } from '@warp-drive-mirror/core/types/request';
-*
-* requestManager.request({
-*   store: store,
-*   url: '/api/posts',
-*   method: 'GET',
-*   [EnableHydration]: true
-* });
-*
-*/
-export declare const CacheHandler: CacheHandlerType;

package/declarations/store/-private/cache-handler/types.d.ts

@@ -1,84 +0,0 @@
-import type { RequestKey } from "../../../types/identifier.js";
-import type { ImmutableRequestInfo, ResponseInfo } from "../../../types/request.js";
-import type { Store } from "../store-service.js";
-/**
-* A service which an application may provide to the store via
-* the store's `lifetimes` property to configure the behavior
-* of the CacheHandler.
-*
-* The default behavior for request lifetimes is to never expire
-* unless manually refreshed via `cacheOptions.reload` or `cacheOptions.backgroundReload`.
-*
-* Implementing this service allows you to programatically define
-* when a request should be considered expired.
-*
-* @public
-*/
-export interface CachePolicy {
-	/**
-	* Invoked to determine if the request may be fulfilled from cache
-	* if possible.
-	*
-	* Note, this is only invoked 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
-	* @return true if the request is considered hard expired
-	*/
-	isHardExpired(identifier: RequestKey, 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 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
-	* @return true if the request is considered soft expired
-	*/
-	isSoftExpired(identifier: RequestKey, store: Store): boolean;
-	/**
-	* Invoked when a request will be sent to the configured request handlers.
-	* This is invoked for both foreground and background requests.
-	*
-	* Note, this is invoked regardless of whether the request has a cache-key.
-	*
-	* @public
-	*/
-	willRequest?(request: ImmutableRequestInfo, identifier: RequestKey | null, store: Store): void;
-	/**
-	* Invoked when a request has been fulfilled from the configured request handlers.
-	* This is invoked for both foreground and background requests once the cache has
-	* been updated.
-	*
-	* Note, this is invoked regardless of whether the request has a cache-key.
-	*
-	* It is best practice to notify the store of any requests marked as invalidated
-	* so that request subscriptions can reload when needed.
-	*
-	* ```ts
-	* store.notifications.notify(identifier, 'invalidated', null);
-	* ```
-	*
-	* This allows anything subscribed to the request to be notified of the change
-	*
-	* e.g.
-	*
-	* ```ts
-	* store.notifications.subscribe(identifier, (_, type) => {
-	*   if (type === 'invalidated') {
-	*     // do update
-	*   }
-	* });
-	* ```
-	*
-	*
-	* @public
-	*/
-	didRequest?(request: ImmutableRequestInfo, response: Response | ResponseInfo | null, identifier: RequestKey | null, store: Store): void;
-}

package/declarations/store/-private/cache-handler/utils.d.ts

@@ -1,31 +0,0 @@
-import type { RequestKey } from "../../../types/identifier.js";
-import type { ImmutableCreateRequestOptions, ImmutableDeleteRequestOptions, ImmutableRequestInfo, ImmutableUpdateRequestOptions, StructuredDataDocument } from "../../../types/request.js";
-import type { ResourceDataDocument, ResourceErrorDocument } from "../../../types/spec/document.js";
-import type { ApiError } from "../../../types/spec/error.js";
-import type { Store } from "../store-service.js";
-export declare const MUTATION_OPS: Set<string>;
-export declare function calcShouldFetch(store: Store, request: ImmutableRequestInfo, hasCachedValue: boolean, identifier: RequestKey | null): boolean;
-export declare function calcShouldBackgroundFetch(store: Store, request: ImmutableRequestInfo, willFetch: boolean, identifier: RequestKey | null): boolean;
-export declare function isMutation(request: Partial<ImmutableRequestInfo>): request is ImmutableUpdateRequestOptions | ImmutableCreateRequestOptions | ImmutableDeleteRequestOptions;
-export declare function isCacheAffecting<T>(document: StructuredDataDocument<T>): boolean;
-export declare function isAggregateError(error: Error & {
-	errors?: ApiError[];
-}): error is AggregateError & {
-	errors: ApiError[];
-};
-export type RobustError = Error & {
-	error: string | object;
-	errors?: ApiError[];
-	content?: unknown;
-};
-export declare function cloneError(error: RobustError): RobustError;
-export declare function isErrorDocument(document: ResourceDataDocument | ResourceErrorDocument): document is ResourceErrorDocument;
-export declare function getPriority(identifier: RequestKey | null, deduped: Map<RequestKey, {
-	priority: {
-		blocking: boolean;
-	};
-}>, priority: {
-	blocking: boolean;
-}): {
-	blocking: boolean;
-};

package/declarations/store/-private/caches/instance-cache.d.ts

@@ -1,58 +0,0 @@
-import { type ReactiveDocument } from "../../../reactive/-private/document.js";
-import type { Cache } from "../../../types/cache.js";
-import type { RequestKey, ResourceKey } from "../../../types/identifier.js";
-import type { TypedRecordInstance, TypeFromInstance } from "../../../types/record.js";
-import type { OpaqueRecordInstance } from "../../-types/q/record-instance.js";
-import { CacheCapabilitiesManager } from "../managers/cache-capabilities-manager.js";
-import type { CacheManager } from "../managers/cache-manager.js";
-import type { CreateRecordProperties, Store } from "../store-service.js";
-export declare function peekResourceKey(record: OpaqueRecordInstance): ResourceKey | undefined;
-/**
-Retrieves the unique referentially-stable {@link ResourceKey}
-assigned to the given record instance.
-
-```js
-import { recordIdentifierFor } from "@warp-drive-mirror/core";
-// ... gain access to a record, for instance with peekRecord or findRecord
-const record = store.peekRecord("user", "1");
-// get the identifier for the record (see docs for ResourceKey)
-const identifier = recordIdentifierFor(record);
-// access the identifier's properties.
-const { id, type, lid } = identifier;
-```
-
-@public
-@param record a record instance previously obstained from the store.
-*/
-export declare function recordIdentifierFor<T extends TypedRecordInstance>(record: T): ResourceKey<TypeFromInstance<T>>;
-export declare function recordIdentifierFor(record: OpaqueRecordInstance): ResourceKey;
-export declare function setRecordIdentifier(record: OpaqueRecordInstance, identifier: ResourceKey): void;
-export declare function removeRecordIdentifier(record: OpaqueRecordInstance): void;
-export declare const StoreMap: Map<unknown, Store>;
-/**
-* We may eventually make this public, but its likely better for this to be killed off
-* @private
-*/
-export declare function storeFor(record: OpaqueRecordInstance, ignoreMissing: boolean): Store | null;
-export type Caches = {
-	record: Map<ResourceKey, OpaqueRecordInstance>;
-	document: Map<RequestKey, ReactiveDocument<OpaqueRecordInstance | OpaqueRecordInstance[] | null | undefined>>;
-};
-export declare class InstanceCache {
-	store: Store;
-	cache: Cache;
-	_storeWrapper: CacheCapabilitiesManager;
-	__cacheManager: CacheManager;
-	__instances: Caches;
-	constructor(store: Store);
-	peek(identifier: ResourceKey): Cache | OpaqueRecordInstance | undefined;
-	getDocument<T>(identifier: RequestKey): ReactiveDocument<T>;
-	getRecord(identifier: ResourceKey): OpaqueRecordInstance;
-	recordIsLoaded(identifier: ResourceKey, filterDeleted?: boolean): boolean;
-	disconnect(identifier: ResourceKey): void;
-	unloadRecord(identifier: ResourceKey): void;
-	clear(type?: string): void;
-	setRecordId(identifier: ResourceKey, id: string): void;
-}
-export declare function getNewRecord(instances: InstanceCache, identifier: ResourceKey, properties: CreateRecordProperties): OpaqueRecordInstance;
-export declare function _clearCaches(): void;

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

@@ -1,9 +0,0 @@
-export declare function hasLid(resource: unknown): resource is {
-	lid: string;
-};
-export declare function hasId(resource: unknown): resource is {
-	id: string;
-};
-export declare function hasType(resource: unknown): resource is {
-	type: string;
-};

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

@@ -1,7 +0,0 @@
-export declare function logGroup(scope: "cache", prefix: string, type: string, lid: string, bucket: string, key: string): void;
-export declare function logGroup(scope: "reactive-ui", prefix: string, type: string, lid: string, bucket: string, key: ""): void;
-export declare function logGroup(scope: "notify", prefix: string, type: string, lid: string, bucket: string, key: string): void;
-export declare function log(scope: "request", prefix: string, type: string, lid: string, bucket: string, key: string): void;
-export declare function log(scope: "cache", prefix: string, type: string, lid: string, bucket: string, key: string): void;
-export declare function log(scope: "reactive-ui", prefix: string, type: string, lid: string, bucket: string, key: ""): void;
-export declare function log(scope: "notify", prefix: string, type: string, lid: string, bucket: string, key: string): void;