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

package/declarations/record-DCFv3y1J.d.ts

@@ -0,0 +1,258 @@
+import { a as Type } from "./symbols-DjRDCeX0.js";
+//#region src/types/record.d.ts
+/**
+ * Records may be anything, They don't even
+ * have to be objects.
+ *
+ * Whatever they are, if they have a Type
+ * property, that property will be used by WarpDrive
+ * and WarpDrive to provide better type safety and
+ * intellisense.
+ *
+ * @class TypedRecordInstance
+ */
+interface TypedRecordInstance {
+  /**
+   * The type of the resource.
+   *
+   * This is an optional feature that can be used by
+   * record implementations to provide a typescript
+   * hint for the type of the resource.
+   *
+   * When used, WarpDrive APIs can
+   * take advantage of this to provide better type
+   * safety and intellisense.
+   *
+   * @property [Type]
+   * @type {Type}
+   * @type {String}
+   */
+  [Type]: string;
+}
+/**
+ * A type utility that extracts the Type if available,
+ * otherwise it returns never.
+ *
+ */
+type TypeFromInstance<T> = T extends TypedRecordInstance ? T[typeof Type] : never;
+/**
+ * A type utility that extracts the Type if available,
+ * otherwise it returns string
+ *
+ */
+type TypeFromInstanceOrString<T> = T extends TypedRecordInstance ? T[typeof Type] : string;
+type IsUniqueSymbol<T> = T extends `___(unique) Symbol(${string})` ? true : false;
+type Unpacked<T> = T extends (infer U)[] ? U : T;
+type NONE = {
+  __NONE: never;
+};
+type __InternalExtract<MAX_DEPTH extends _DEPTHCOUNT, T extends TypedRecordInstance, V extends TypedRecordInstance, IncludePrefix extends boolean, Ignore, Pre extends string, DEPTH extends _DEPTHCOUNT> = V extends T ? IncludePrefix extends false ? V[typeof Type] : Pre : V extends Ignore ? IncludePrefix extends false ? V[typeof Type] : Pre : IS_MAX_DEPTH<DEPTH, MAX_DEPTH> extends true ? Pre : ExtractUnion<MAX_DEPTH, V, IncludePrefix, Ignore | T, Pre, INC_DEPTH<DEPTH>>;
+type __ExtractIfRecord<MAX_DEPTH extends _DEPTHCOUNT, T extends TypedRecordInstance, V, IncludePrefix extends boolean, Ignore, Pre extends string, DEPTH extends _DEPTHCOUNT> = V extends TypedRecordInstance ? __InternalExtract<MAX_DEPTH, T, V, IncludePrefix, Ignore, Pre, DEPTH> : never;
+type _ExtractUnion<MAX_DEPTH extends _DEPTHCOUNT, T extends TypedRecordInstance, IncludePrefix extends boolean, Ignore, Pre, DEPTH extends _DEPTHCOUNT> = { [K in keyof T]: IsUniqueSymbol<K> extends true ? never : K extends string ? __ExtractIfRecord<MAX_DEPTH, T, Unpacked<Awaited<T[K]>>, IncludePrefix, Ignore, Pre extends string ? `${Pre}.${K}` : K, DEPTH> : never; }[keyof T];
+/**
+ * A Utility that extracts either resource types or resource paths from a TypedRecordInstance.
+ *
+ * Its limitations are mostly around its intentional non-recursiveness. It presumes that APIs which
+ * implement includes will not allow cyclical include paths, and will collapse includes by type.
+ *
+ * This follows closer to the JSON:API fields spec than to the includes spec in nature, but in
+ * practice it is so impracticle for an API to allow z-algo include paths that this is probably
+ * reasonable.
+ *
+ * We may need to revisit this in the future, opting to either make this restriction optional or
+ * to allow for other strategies.
+ *
+ * There's a 90% chance this particular implementation belongs being in the JSON:API package instead
+ * of core-types, but it's here for now.
+ *
+ */
+type ExtractUnion<MAX_DEPTH extends _DEPTHCOUNT, T extends TypedRecordInstance, IncludePrefix extends boolean = false, Ignore = NONE, Pre = NONE, DEPTH extends _DEPTHCOUNT = 1> = Exclude<IncludePrefix extends true ? _ExtractUnion<MAX_DEPTH, T, IncludePrefix, Ignore, Pre, DEPTH> | Pre : _ExtractUnion<MAX_DEPTH, T, IncludePrefix, Ignore, Pre, DEPTH> | T[typeof Type], NONE>;
+type _DEPTHCOUNT = 1 | 2 | 3 | 4 | 5;
+type INC_DEPTH<START extends _DEPTHCOUNT> = START extends 1 ? 2 : START extends 2 ? 3 : START extends 3 ? 4 : 5;
+type IS_MAX_DEPTH<DEPTH extends _DEPTHCOUNT, MAX_DEPTH extends _DEPTHCOUNT = DEFAULT_MAX_DEPTH> = DEPTH extends MAX_DEPTH ? true : false;
+type DEFAULT_MAX_DEPTH = 3;
+/**
+ * A utility that provides the union of all ResourceName for all potential
+ * includes for the given TypedRecordInstance.
+ *
+ */
+type ExtractSuggestedCacheTypes<T extends TypedRecordInstance, MAX_DEPTH extends _DEPTHCOUNT = DEFAULT_MAX_DEPTH> = ExtractUnion<MAX_DEPTH, T>;
+/**
+ * A utility that provides the union type of all valid include paths for the given
+ * TypedRecordInstance.
+ *
+ * Cyclical paths are filtered out.
+ *
+ */
+type Includes<T extends TypedRecordInstance, MAX_DEPTH extends _DEPTHCOUNT = DEFAULT_MAX_DEPTH> = ExtractUnion<MAX_DEPTH, T, true>;
+/**
+ * A type-erased placeholder for a record instance, used where the
+ * specific record type is not known or not relevant.
+ */
+type OpaqueRecordInstance = unknown;
+/**
+ * @internal
+ */
+type _StringSatisfiesIncludes<T extends string, SET extends string, FT extends string> = T extends SET ? FT : T extends `${infer U},${infer V}` ? U extends SET ? _StringSatisfiesIncludes<V, Exclude<SET, U>, FT> : never : never;
+/**
+ * Validates that the comma-separated-string `T` (e.g. `'company,company.ceo,friends'`)
+ * only contains paths present in the union `SET` (typically {@link Includes}).
+ *
+ * TypeScript cannot autocomplete against this type; prefer {@link createIncludeValidator}
+ * for a better development experience unless you are writing a similar wrapper utility.
+ *
+ * @example
+ * ```ts
+ * import type { StringSatisfiesIncludes, Includes } from '@warp-drive-mirror/core/types/record';
+ *
+ * const includes: StringSatisfiesIncludes<
+ *   'company,company.ceo,friends',
+ *   Includes<User>
+ * > = 'company,company.ceo,friends';
+ * ```
+ */
+type StringSatisfiesIncludes<T extends string, SET extends string> = _StringSatisfiesIncludes<T, SET, T>;
+/**
+ * Creates a runtime validator function for comma-separated `include` strings,
+ * ensuring at compile time that only valid paths for `T` (per {@link Includes})
+ * are supplied.
+ *
+ * @example
+ * ```ts
+ * import { createIncludeValidator } from '@warp-drive-mirror/core/types/record';
+ *
+ * const userIncludesValidator = createIncludeValidator<User>;
+ *
+ * userIncludesValidator('company,company.ceo,friends');
+ * ```
+ */
+declare function createIncludeValidator<T extends TypedRecordInstance>(): <U extends string>(includes: StringSatisfiesIncludes<U, Includes<T>>) => U;
+/**
+ * A utility that takes two types, K and T, and produces a new type that is a "mask" of T based on K.
+ *
+ * That's a mouthful, so let's break it down:
+ *
+ * Let's say you have a User type and an Address type.
+ *
+ * ```ts
+ * interface Address {
+ *   street: string;
+ *   city: string;
+ *   state: string;
+ *   zip: string;
+ * }
+ *
+ * interface User {
+ *   name: string;
+ *   title: string;
+ *   address: Address;
+ * }
+ * ```
+ *
+ * Now, imagine you want to load a preview of the user with some information about their address,
+ * but you don't want to load the entire user or address. You probably want to still ensure
+ * the type of the data you do load matches the underlying Address and User types, but doesn't
+ * include everything.
+ *
+ * If you did this manually, you might do something like this:
+ *
+ * ```ts
+ * interface UserPreview {
+ *   name: string;
+ *   address: AddressPreview;
+ * }
+ *
+ * interface AddressPreview {
+ *   city: string;
+ * }
+ * ```
+ *
+ * From a TypeScript performance perspective, this is the best way to approach these preview
+ * types, but this is also tedious and error-prone, especially if the User or Address types change.
+ *
+ * For Address, we could create a validated type using `Pick`:
+ *
+ * ```ts
+ * type AddressPreview = Pick<Address, 'city'>;
+ * ```
+ *
+ * This ensures that if the Address type changes, our AddressPreview will still be valid.
+ * However, for UserPreview, we can't just use `Pick` because the `address` property is of type `Address`,
+ * not `AddressPreview`. This is where the `Mask` type comes in.
+ *
+ * With `Mask`, we define the `UserPreview` in two parts
+ * - first, we define the subset of fields we want to include from `User`, using `Pick` or an interface.
+ * - then, we use `Mask` to replace the related types of fields like Address with their more limited subset.
+ *
+ * Here's how we can do it:
+ *
+ * ```ts
+ * // First, we define the base of UserPreview with Pick
+ * type UserPreviewBase = Pick<User, 'name' | 'address'>;
+ * // Then, we use Mask to replace Address with AddressPreview
+ * type UserPreview = Mask<{ address: AddressPreview }, UserPreviewBase>;
+ * ```
+ *
+ * Now, `UserPreview` will have the `name` field from `User` and the `address` field will be of type `AddressPreview`.
+ * This way, if the `User` or `Address` types change, TypeScript will ensure that our `UserPreview` and `AddressPreview`
+ * types remain valid and consistent with the underlying types.
+ *
+ * But what if your app has data with massive interfaces such that the TypeScript performance of this
+ * approach becomes a problem? In that case, see {@link Validate}
+ */
+type Mask<K extends object, T extends K> = { [P in keyof T]: P extends keyof K ? (T[P] extends K[P] ? K[P] : never) : T[P]; };
+/**
+ * A utility that takes two types, K and T, and ensures that K is a valid subset of T.
+ *
+ * That's a mouthful, so let's break it down:
+ *
+ * Let's say you have a User type and an Address type.
+ *
+ * ```ts
+ * interface Address {
+ *   street: string;
+ *   city: string;
+ *   state: string;
+ *   zip: string;
+ * }
+ *
+ * interface User {
+ *   name: string;
+ *   title: string;
+ *   address: Address;
+ * }
+ * ```
+ *
+ * Now, imagine you want to load a preview of the user with some information about their address,
+ * but you don't want to load the entire user or address. You probably want to still ensure
+ * the type of the data you do load matches the underlying Address and User types, but doesn't
+ * include everything.
+ *
+ * You might do something like this:
+ *
+ * ```ts
+ * interface UserPreview {
+ *   name: string;
+ *   address: AddressPreview;
+ * }
+ *
+ * interface AddressPreview {
+ *   city: string;
+ * }
+ * ```
+ *
+ * From a TypeScript performance perspective, this is the best way to approach these preview
+ * types, but this is also error-prone, especially if the User or Address types change.
+ *
+ * Validate can help ensure that your preview types remain valid.
+ *
+ * ```ts
+ * type IsValidUserPreview = Validate<UserPreview, User>; // This will be valid
+ * ```
+ *
+ * For help creating subsets of types, see {@link Mask}
+ */
+type Validate<K extends object, T extends K> = T extends K ? K : never;
+//#endregion
+export { StringSatisfiesIncludes as a, TypedRecordInstance as c, createIncludeValidator as d, OpaqueRecordInstance as i, Validate as l, Includes as n, TypeFromInstance as o, Mask as r, TypeFromInstanceOrString as s, ExtractSuggestedCacheTypes as t, _StringSatisfiesIncludes as u };
+//# sourceMappingURL=record-DCFv3y1J.d.ts.map

package/declarations/record-DCFv3y1J.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"record-DCFv3y1J.d.ts","names":[],"sources":["../src/types/record.ts"],"mappings":";;;;;;;;;;;;;UAaiB;;;;;;;;;;;;;;;;GAgBd;;;;;;;KAQS,iBAAiB,KAAK,UAAU,sBAAsB,SAAS;;;;;;KAO/D,yBAAyB,KAAK,UAAU,sBAAsB,SAAS;KAE9E,eAAe,KAAK;KACpB,SAAS,KAAK,iBAAiB,OAAO,IAAI;KAC1C;EAAS;;KAET,kBACH,kBAAkB,aAClB,UAAU,qBACV,UAAU,qBACV,+BACA,QACA,oBACA,cAAc,eAGd,UAAU,IACN,8BACE,SAAS,QACT,MAEF,UAAU,SACR,8BACE,SAAS,QACT,MAEF,aAAa,OAAO,0BAClB,MAEA,aAAa,WAAW,GAAG,eAAe,SAAS,GAAG,KAAK,UAAU;KAE1E,kBACH,kBAAkB,aAClB,UAAU,qBACV,GACA,+BACA,QACA,oBACA,cAAc,eACZ,UAAU,sBAAsB,kBAAkB,WAAW,GAAG,GAAG,eAAe,QAAQ,KAAK;KAE9F,cACH,kBAAkB,aAClB,UAAU,qBACV,+BACA,QACA,KACA,cAAc,kBAGb,WAAW,IAAI,eAAe,0BAE3B,mBAEE,kBACE,WACA,GACA,SAAS,QAAQ,EAAE,MACnB,eACA,QACA,wBAAwB,OAAO,MAAM,GACrC,wBAIF;;;;;;;;;;;;;;;;;;KAmBH,aACH,kBAAkB,aAClB,UAAU,qBACV,uCACA,SAAS,MACT,MAAM,MACN,cAAc,mBACZ,QACF,6BAEM,cAAc,WAAW,GAAG,eAAe,QAAQ,KAAK,SAAS,MAEjE,cAAc,WAAW,GAAG,eAAe,QAAQ,KAAK,SAAS,SAAS,OAChF;KAGG;KACA,UAAU,cAAc,eAAe,sBAAsB,sBAAsB;KACnF,aACH,cAAc,aACd,kBAAkB,cAAc,qBAC9B,cAAc;KACb;;;;;;KAMO,2BACV,UAAU,qBACV,kBAAkB,cAAc,qBAC9B,aAAa,WAAW;;;;;;;;KAShB,SAAS,UAAU,qBAAqB,kBAAkB,cAAc,qBAAqB,aACvG,WACA;;;;;KAQU;;;;KAKA,yBAAyB,kBAAkB,oBAAoB,qBAAqB,UAAU,MACtG,KACA,mBAAmB,WAAW,MAC5B,UAAU,MACR,yBAAyB,GAAG,QAAQ,KAAK,IAAI;;;;;;;;;;;;;;;;;;KAqBzC,wBAAwB,kBAAkB,sBAAsB,yBAAyB,GAAG,KAAK;;;;;;;;;;;;;;;iBAgB7F,uBAAuB,UAAU,yBACd,kBAAkB,UAAU,wBAAwB,GAAG,SAAS,QAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA8E7F,KAAK,kBAAkB,UAAU,QAC1C,WAAW,IAAI,gBAAgB,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,cAAc,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAsDjE,SAAS,kBAAkB,UAAU,KAAK,UAAU,IAAI"}

package/declarations/relationship-CT9mFtav.d.ts

@@ -0,0 +1,65 @@
+import { l as ResourceKey } from "./identifier-DyEvjMjb.js";
+import { d as Meta, m as PaginationLinks, u as Links } from "./json-api-raw-C5APJHHB.js";
+//#region src/types/cache/relationship.d.ts
+/**
+ * The stable-cache-key form of a `to-one` {@link SingleResourceRelationship | relationship}.
+ *
+ * Unlike {@link SingleResourceRelationship}, `data` is always in the
+ * stable {@link ResourceKey} form rather than a raw resource identifier.
+ *
+ * @example
+ * ```ts
+ * const relationship: ResourceRelationship = { data: resourceKey };
+ * ```
+ */
+interface ResourceRelationship<T = ResourceKey> {
+  /**
+   * the related resource, or `null` if the relationship has no related resource
+   */
+  data?: T | null;
+  /**
+   * meta information about the relationship
+   */
+  meta?: Meta;
+  /**
+   * links related to the relationship
+   */
+  links?: Links;
+}
+/**
+ * The stable-cache-key form of a `to-many` {@link CollectionResourceRelationship | relationship}.
+ *
+ * Unlike {@link CollectionResourceRelationship}, each entry in `data` is
+ * always in the stable {@link ResourceKey} form rather than a raw resource
+ * identifier.
+ *
+ * @example
+ * ```ts
+ * const relationship: CollectionRelationship = { data: [resourceKey] };
+ * ```
+ */
+interface CollectionRelationship<T = ResourceKey> {
+  /**
+   * the related resources
+   */
+  data?: T[];
+  /**
+   * meta information about the relationship
+   */
+  meta?: Meta;
+  /**
+   * links related to the relationship, including pagination links
+   */
+  links?: PaginationLinks;
+}
+/**
+ * The stable-cache-key form of a relationship, whether `to-one` or `to-many`.
+ *
+ * See also:
+ * - {@link ResourceRelationship}
+ * - {@link CollectionRelationship}
+ */
+type Relationship<T = ResourceKey> = ResourceRelationship<T> | CollectionRelationship<T>;
+//#endregion
+export { Relationship as n, ResourceRelationship as r, CollectionRelationship as t };
+//# sourceMappingURL=relationship-CT9mFtav.d.ts.map

package/declarations/relationship-CT9mFtav.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relationship-CT9mFtav.d.ts","names":[],"sources":["../src/types/cache/relationship.ts"],"mappings":";;;;;;;;;;;;;;UAsBiB,qBAAqB,IAAI;;;;EAIxC,OAAO;;;;EAIP,OAAO;;;;EAIP,QAAQ;;;;;;;;;;;;;;UAeO,uBAAuB,IAAI;;;;EAI1C,OAAO;;;;EAIP,OAAO;;;;EAIP,QAAQ;;;;;;;;;KAUE,aAAa,IAAI,eAAe,qBAAqB,KAAK,uBAAuB"}

package/declarations/request.d.ts

@@ -1,52 +1,2 @@
-import type { ReactiveDataDocument } from "./reactive.js";
-import type { RequestInfo } from "./types/request.js";
-import type { RequestSignature } from "./types/symbols.js";
-export { createDeferred } from "./request/-private/future.js";
-export type { Future, Handler, CacheHandler, NextFn, Deferred, ManagedRequestPriority } from "./request/-private/types.js";
-export { setPromiseResult, getPromiseResult } from "./request/-private/promise-cache.js";
-export type { Awaitable } from "./request/-private/promise-cache.js";
-export type { Context } from "./request/-private/context.js";
-/**
-* Brands the supplied object with the supplied response type.
-*
-* ```ts
-* import type { ReactiveDataDocument } from '@warp-drive-mirror/core/reactive';
-* import { withResponseType } from '@warp-drive-mirror/core/request';
-* import type { User } from '#/data/user.ts'
-*
-* const result = await store.request(
-*  withResponseType<ReactiveDataDocument<User>>({ url: '/users/1' })
-* );
-*
-* result.content.data; // will have type User
-* ```
-*
-*/
-export declare function withResponseType<T>(obj: RequestInfo): RequestInfo<T> & {
-	[RequestSignature]: T;
-};
-/**
-* Brands the supplied object with the supplied response type
-* wrapped in {@link ReactiveDataDocument}. This is a convenience for
-* the common case of using {@link withResponseType} with `ReactiveDataDocument`.
-*
-* ```ts
-* import { withReactiveResponse } from '@warp-drive-mirror/core/request';
-* import type { User } from '#/data/user.ts'
-*
-* const result = await store.request(
-*   withReactiveResponse<User>({ url: '/users/1' })
-* );
-*
-* result.content.data; // will have type User
-* ```
-*
-* @public
-*/
-export declare function withReactiveResponse<T>(obj: RequestInfo): RequestInfo<ReactiveDataDocument<T>> & {
-	[RequestSignature]: ReactiveDataDocument<T>;
-};
-/**
-* @deprecated use {@link withResponseType} instead
-*/
-export declare const withBrand: typeof withResponseType;
+import { At as setPromiseResult, Bn as Handler, Dt as withResponseType, Et as withReactiveResponse, Hn as NextFn, In as Context, Ln as CacheHandler, Ot as Awaitable, Rn as Deferred, Tt as withBrand, Vn as ManagedRequestPriority, jt as createDeferred, kt as getPromiseResult, zn as Future } from "./internal-DMxLqCZa.js";
+export { type Awaitable, type CacheHandler, type Context, type Deferred, type Future, type Handler, type ManagedRequestPriority, type NextFn, createDeferred, getPromiseResult, setPromiseResult, withBrand, withReactiveResponse, withResponseType };

package/declarations/signals/-leaked.d.ts

@@ -1,2 +1,63 @@
-export { defineNonEnumerableSignal, defineGate, defineSignal, entangleSignal, signal, waitFor, gate, DISPOSE, memoized, notifyInternalSignal, peekInternalSignal, withSignalStore } from "./-private.js";
-export type { AutorefreshBehaviorCombos, SubscriptionArgs, ContentFeatures, RecoveryFeatures, RequestArgs } from "./-private.js";
+import { a as notifyInternalSignal, c as AutorefreshBehaviorCombos, d as RecoveryFeatures, f as RequestArgs, i as makeInitializer, l as ContentFeatures, m as SubscriptionArgs, n as WarpDriveSignal, o as peekInternalSignal, r as getOrCreateInternalSignal, s as withSignalStore, t as SignalStore, u as DISPOSE } from "../internal-DMxLqCZa.js";
+import { o as waitFor } from "../configure-DI1HqQpX.js";
+//#region src/signals/reactivity/signal.d.ts
+/**
+ * Creates a signal for the key/object pairing and subscribes to the signal.
+ *
+ * Use when you need to ensure a signal exists and is subscribed to.
+ *
+ * @private
+ */
+declare function entangleSignal<T extends object>(signals: SignalStore, obj: T, key: string | symbol, initialValue: unknown): WarpDriveSignal;
+/**
+ * define an enumerable signal property.
+ *
+ * Akin to Object.defineProperty.
+ *
+ * The signal will be lazily created when accessed and scoped to the
+ * instance of the object.
+ *
+ * @private
+ */
+declare function defineSignal<T extends object>(obj: T, key: string, v?: unknown): void;
+/**
+ * Define a non-enumerable signal property.
+ *
+ * @private
+ */
+declare function defineNonEnumerableSignal<T extends object>(obj: T, key: string, v?: unknown): void;
+interface DecoratorPropertyDescriptor extends PropertyDescriptor {
+  initializer?: () => unknown;
+}
+/**
+ * Decorator version of creating a signal.
+ */
+declare function signal<T extends object, K extends keyof T & string>(target: T, key: K, descriptor?: DecoratorPropertyDescriptor): void;
+/**
+ * Decorator version of creating a memoized getter
+ */
+declare function memoized<T extends object, K extends keyof T & string>(target: T, key: K, descriptor: PropertyDescriptor): PropertyDescriptor;
+/**
+ * Decorator version of creating a gate.
+ *
+ * @private
+ */
+declare function gate<T extends object, K extends keyof T & string>(_target: T, key: K, desc: PropertyDescriptor): PropertyDescriptor;
+/**
+ * Defines a reactive "gated" property on `obj` using `desc` as its
+ * getter/setter descriptor.
+ *
+ * Unlike a signal defined with {@link defineSignal}, a gated property's
+ * consumers are not notified when the property is set, since its update
+ * is expected to be controlled externally (for instance, by a signal it
+ * derives its value from) unless the descriptor opts into being locally
+ * managed.
+ *
+ * Akin to `Object.defineProperty`.
+ *
+ * @private
+ */
+declare function defineGate<T extends object>(obj: T, key: string, desc: PropertyDescriptor): void;
+//#endregion
+export { type AutorefreshBehaviorCombos, type ContentFeatures, DISPOSE, type RecoveryFeatures, type RequestArgs, type SignalStore, type SubscriptionArgs, defineGate, defineNonEnumerableSignal, defineSignal, entangleSignal, gate, getOrCreateInternalSignal, makeInitializer, memoized, notifyInternalSignal, peekInternalSignal, signal, waitFor, withSignalStore };
+//# sourceMappingURL=-leaked.d.ts.map

package/declarations/signals/-leaked.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"-leaked.d.ts","names":[],"sources":["../../src/signals/reactivity/signal.ts"],"mappings":";;;;;;;;;;iBAqBgB,eAAe,kBAC7B,SAAS,aACT,KAAK,GACL,sBACA,wBACC;;;;;;;;;;;iBA0Da,aAAa,kBAAkB,KAAK,GAAG,aAAa;;;;;;iBASpD,0BAA0B,kBAAkB,KAAK,GAAG,aAAa;UAMvE,oCAAoC;EAC5C;;;;;iBAMc,OAAO,kBAAkB,gBAAgB,YACvD,QAAQ,GACR,KAAK,GACL,aAAa;;;;iBA2BC,SAAS,kBAAkB,gBAAgB,YACzD,QAAQ,GACR,KAAK,GACL,YAAY,qBACX;;;;;;iBAyCa,KAAK,kBAAkB,gBAAgB,YACrD,SAAS,GACT,KAAK,GACL,MAAM,qBACL;;;;;;;;;;;;;;;iBA2Da,WAAW,kBAAkB,KAAK,GAAG,aAAa,MAAM"}

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

@@ -1,24 +1,2 @@
-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";
+import { $ as SaveRecordMutation, B as coerceId, Ct as StoreRequestContext, F as log, G as Store, H as constructResource, I as logGroup, J as FindRecordQuery, K as assertPrivateStore, L as LegacyManyArray, Q as RequestStateService, R as createLegacyManyArray, St as CacheHandler, U as CreateRecordProperties, V as ensureStringId, W as PrivateStore, X as Request, Y as PrivateRequestStateService, Z as RequestCacheRequestState, _t as assertPrivateCapabilities, at as ReactiveResourceArray, dt as StoreMap, et as RecordArrayManager, ft as _clearCaches, gt as PrivateCacheCapabilitiesManager, ht as storeFor, it as PrivateReactiveResourceArray, lt as NativeProxy, mt as setRecordIdentifier, nn as isRequestKey, nt as LegacyQueryArray, pt as recordIdentifierFor, q as isPrivateStore, rn as isResourceKey, rt as LegacyLiveArray, tt as fastPush, ut as InstanceCache, wt as StoreRequestInput, xt as CachePolicy, z as normalizeModelName } from "../internal-DMxLqCZa.js";
+export { CacheHandler, type CachePolicy, type LegacyQueryArray as CollectionRecordArray, type LegacyQueryArray, type CreateRecordProperties, type FindRecordQuery, type InstanceCache, type LegacyLiveArray, type LegacyLiveArray as LiveArray, type LegacyManyArray, type LegacyManyArray as RelatedCollection, type NativeProxy, type PrivateCacheCapabilitiesManager, type PrivateReactiveResourceArray, type PrivateRequestStateService, type PrivateStore, type ReactiveResourceArray, RecordArrayManager, type Request, type RequestCacheRequestState, type RequestStateService, type SaveRecordMutation, Store, StoreMap, type StoreRequestContext, type StoreRequestInput, _clearCaches, normalizeModelName as _deprecatingNormalize, assertPrivateCapabilities, assertPrivateStore, coerceId, constructResource, createLegacyManyArray, ensureStringId, fastPush, isPrivateStore, isRequestKey, isResourceKey, log, logGroup, recordIdentifierFor, setRecordIdentifier, storeFor };