@warp-drive/core 5.6.0-alpha.11

package/declarations/store/-private/network/request-cache.d.ts

@@ -0,0 +1,104 @@
+import type { StableRecordIdentifier } from '../../../types/identifier.ts';
+import type { FindRecordOptions } from '../../-types/q/store.ts';
+import type { Store } from '../store-service.ts';
+declare const Touching: "___(unique) Symbol(Touching)";
+export declare const RequestPromise: "___(unique) Symbol(RequestPromise)";
+export interface Operation {
+    op: string;
+    options: FindRecordOptions | undefined;
+    recordIdentifier: StableRecordIdentifier;
+}
+export interface FindRecordQuery extends Operation {
+    op: 'findRecord';
+}
+export interface SaveRecordMutation extends Operation {
+    op: 'saveRecord';
+}
+export interface Request {
+    data: Operation[];
+    options?: Record<string, unknown>;
+}
+export type RequestStates = 'pending' | 'fulfilled' | 'rejected';
+export interface RequestCacheRequestState {
+    state: RequestStates;
+    type: 'query' | 'mutation';
+    request: Request;
+    response?: Response;
+}
+export interface Response {
+    data: unknown;
+}
+interface InternalRequest extends RequestCacheRequestState {
+    [Touching]: StableRecordIdentifier[];
+    [RequestPromise]?: Promise<unknown>;
+}
+export type RequestSubscription = (requestState: RequestCacheRequestState) => void;
+/**
+ * The RequestStateService is used to track the state of requests
+ * for fetching or updating known resource identifies that are inflight.
+ *
+ * @class RequestStateService
+ * @public
+ */
+export declare class RequestStateService {
+    _pending: Map<StableRecordIdentifier, InternalRequest[]>;
+    _done: Map<StableRecordIdentifier, InternalRequest[]>;
+    _subscriptions: Map<StableRecordIdentifier, RequestSubscription[]>;
+    _toFlush: InternalRequest[];
+    _store: Store;
+    constructor(store: Store);
+    _clearEntries(identifier: StableRecordIdentifier): void;
+    _enqueue<T>(promise: Promise<T>, queryRequest: Request): Promise<T>;
+    _triggerSubscriptions(req: InternalRequest): void;
+    _flush(): void;
+    _flushRequest(req: InternalRequest): void;
+    _dequeue(identifier: StableRecordIdentifier, request: InternalRequest): void;
+    _addDone(request: InternalRequest): void;
+    /**
+     * Subscribe to requests for a given resource identity.
+     *
+     * The callback will receive the current state of the request.
+     *
+     * ```ts
+     * interface RequestState {
+     *   state: 'pending' | 'fulfilled' | 'rejected';
+     *   type: 'query' | 'mutation';
+     *   request: Request;
+     *   response?: { data: unknown };
+     * }
+     * ```
+     *
+     * Note: It should be considered dangerous to use this API for more than simple
+     * state derivation or debugging. The `request` and `response` properties are poorly
+     * spec'd and may change unexpectedly when shifting what Handlers are in use or how
+     * requests are issued from the Store.
+     *
+     * We expect to revisit this API in the near future as we continue to refine the
+     * RequestManager ergonomics, as a simpler but more powerful direct integration
+     * with the RequestManager for these purposes is likely to be a better long-term
+     * design.
+     *
+     * @public
+     * @param {StableRecordIdentifier} identifier
+     * @param {(state: RequestCacheRequestState) => void} callback
+     */
+    subscribeForRecord(identifier: StableRecordIdentifier, callback: RequestSubscription): void;
+    /**
+     * Retrieve all active requests for a given resource identity.
+     *
+     * @public
+     * @param {StableRecordIdentifier} identifier
+     * @return {RequestCacheRequestState[]} an array of request states for any pending requests for the given identifier
+     */
+    getPendingRequestsForRecord(identifier: StableRecordIdentifier): RequestCacheRequestState[];
+    /**
+     * Retrieve the last completed request for a given resource identity.
+     *
+     * @public
+     * @param {StableRecordIdentifier} identifier
+     * @return {RequestCacheRequestState | null} the state of the most recent request for the given identifier
+     */
+    getLastRequestForRecord(identifier: StableRecordIdentifier): RequestCacheRequestState | null;
+}
+export {};
+//# sourceMappingURL=request-cache.d.ts.map

package/declarations/store/-private/network/request-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-cache.d.ts","sourceRoot":"","sources":["../../../../src/store/-private/network/request-cache.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,8BAA8B,CAAC;AAC3E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AACjE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAEjD,QAAA,MAAM,QAAQ,gCAAiD,CAAC;AAChE,eAAO,MAAM,cAAc,sCAAsD,CAAC;AAGlF,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,iBAAiB,GAAG,SAAS,CAAC;IACvC,gBAAgB,EAAE,sBAAsB,CAAC;CAC1C;AAED,MAAM,WAAW,eAAgB,SAAQ,SAAS;IAChD,EAAE,EAAE,YAAY,CAAC;CAClB;AAED,MAAM,WAAW,kBAAmB,SAAQ,SAAS;IACnD,EAAE,EAAE,YAAY,CAAC;CAClB;AAED,MAAM,WAAW,OAAO;IACtB,IAAI,EAAE,SAAS,EAAE,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC;AAED,MAAM,MAAM,aAAa,GAAG,SAAS,GAAG,WAAW,GAAG,UAAU,CAAC;AAEjE,MAAM,WAAW,wBAAwB;IACvC,KAAK,EAAE,aAAa,CAAC;IACrB,IAAI,EAAE,OAAO,GAAG,UAAU,CAAC;IAC3B,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,EAAE,QAAQ,CAAC;CACrB;AAED,MAAM,WAAW,QAAQ;IAEvB,IAAI,EAAE,OAAO,CAAC;CACf;AAED,UAAU,eAAgB,SAAQ,wBAAwB;IACxD,CAAC,QAAQ,CAAC,EAAE,sBAAsB,EAAE,CAAC;IACrC,CAAC,cAAc,CAAC,CAAC,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;CACrC;AAGD,MAAM,MAAM,mBAAmB,GAAG,CAAC,YAAY,EAAE,wBAAwB,KAAK,IAAI,CAAC;AAMnF;;;;;;GAMG;AACH,qBAAa,mBAAmB;IAC9B,QAAQ,EAAE,GAAG,CAAC,sBAAsB,EAAE,eAAe,EAAE,CAAC,CAAa;IACrE,KAAK,EAAE,GAAG,CAAC,sBAAsB,EAAE,eAAe,EAAE,CAAC,CAAa;IAClE,cAAc,EAAE,GAAG,CAAC,sBAAsB,EAAE,mBAAmB,EAAE,CAAC,CAAa;IAC/E,QAAQ,EAAE,eAAe,EAAE,CAAM;IACjC,MAAM,EAAE,KAAK,CAAC;gBAEF,KAAK,EAAE,KAAK;IAIxB,aAAa,CAAC,UAAU,EAAE,sBAAsB;IAIhD,QAAQ,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,YAAY,EAAE,OAAO,GAAG,OAAO,CAAC,CAAC,CAAC;IAiDnE,qBAAqB,CAAC,GAAG,EAAE,eAAe,GAAG,IAAI;IAcjD,MAAM,IAAI,IAAI;IAOd,aAAa,CAAC,GAAG,EAAE,eAAe,GAAG,IAAI;IASzC,QAAQ,CAAC,UAAU,EAAE,sBAAsB,EAAE,OAAO,EAAE,eAAe;IAQrE,QAAQ,CAAC,OAAO,EAAE,eAAe;IAwBjC;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,kBAAkB,CAAC,UAAU,EAAE,sBAAsB,EAAE,QAAQ,EAAE,mBAAmB;IASpF;;;;;;OAMG;IACH,2BAA2B,CAAC,UAAU,EAAE,sBAAsB,GAAG,wBAAwB,EAAE;IAI3F;;;;;;OAMG;IACH,uBAAuB,CAAC,UAAU,EAAE,sBAAsB,GAAG,wBAAwB,GAAG,IAAI;CAO7F"}

package/declarations/store/-private/new-core-tmp/promise-state.d.ts

@@ -0,0 +1,255 @@
+import type { Awaitable } from '../../../request.ts';
+/**
+ * The state of a promise in the "pending"
+ * state. This is the default initial state.
+ *
+ */
+export interface PendingPromise {
+    /**
+     * The status of the promise.
+     *
+     */
+    status: 'pending';
+    /**
+     * Whether the promise is pending.
+     *
+     */
+    isPending: true;
+    /**
+     * Whether the promise is pending.
+     *
+     * @deprecated use `isPending` instead
+     */
+    isLoading: true;
+    /**
+     * Whether the promise has resolved
+     * successfully.
+     *
+     */
+    isSuccess: false;
+    /**
+     * Whether the promise has rejected
+     * with an error.
+     *
+     */
+    isError: false;
+    /**
+     * Once the promise has resolved, this will
+     * be the value the promise resolved to.
+     *
+     */
+    value: null;
+    /**
+     * Once the promise has resolved, this will
+     * be the value the promise resolved to.
+     *
+     * @deprecated use `value` instead
+     */
+    result: null;
+    /**
+     * Once the promise has rejected, this will
+     * be the error the promise rejected with.
+     *
+     *
+     * @deprecated use `reason` instead
+     */
+    error: null;
+    /**
+     * Once the promise has rejected, this will
+     * be the error the promise rejected with.
+     *
+     */
+    reason: null;
+}
+/**
+ * The state of a promise in the "fulfilled" state.
+ * This is the state of a promise that has resolved
+ * successfully.
+ *
+ */
+export interface ResolvedPromise<T> {
+    /**
+     * The status of the promise.
+     *
+     */
+    status: 'fulfilled';
+    /**
+     * Whether the promise is pending.
+     *
+     */
+    isPending: false;
+    /**
+     * Whether the promise is pending.
+     *
+     * @deprecated use `isPending` instead
+     */
+    isLoading: false;
+    /**
+     * Whether the promise has resolved
+     * successfully.
+     *
+     */
+    isSuccess: true;
+    /**
+     * Whether the promise has rejected
+     * with an error.
+     *
+     */
+    isError: false;
+    /**
+     * Once the promise has resolved, this will
+     * be the value the promise resolved to.
+     *
+     */
+    value: T;
+    /**
+     * Once the promise has resolved, this will
+     * be the value the promise resolved to.
+     *
+     * @deprecated use `value` instead
+     */
+    result: T;
+    /**
+     * Once the promise has rejected, this will
+     * be the error the promise rejected with.
+     *
+     *
+     * @deprecated use `reason` instead
+     */
+    error: null;
+    /**
+     * Once the promise has rejected, this will
+     * be the error the promise rejected with.
+     *
+     */
+    reason: null;
+}
+/**
+ * The state of a promise in the "rejected" state.
+ * This is the state of a promise that has rejected
+ * with an error.
+ *
+ */
+export interface RejectedPromise<E> {
+    /**
+     * The status of the promise.
+     *
+     */
+    status: 'rejected';
+    /**
+     * Whether the promise is pending.
+     *
+     */
+    isPending: false;
+    /**
+     * Whether the promise is pending.
+     *
+     * @deprecated use `isPending` instead
+     */
+    isLoading: false;
+    /**
+     * Whether the promise has resolved
+     * successfully.
+     *
+     */
+    isSuccess: false;
+    /**
+     * Whether the promise has rejected
+     * with an error.
+     *
+     */
+    isError: true;
+    /**
+     * Once the promise has resolved, this will
+     * be the value the promise resolved to.
+     *
+     */
+    value: null;
+    /**
+     * Once the promise has resolved, this will
+     * be the value the promise resolved to.
+     *
+     * @deprecated use `value` instead
+     */
+    result: null;
+    /**
+     * Once the promise has rejected, this will
+     * be the error the promise rejected with.
+     *
+     *
+     * @deprecated use `reason` instead
+     */
+    error: E;
+    /**
+     * Once the promise has rejected, this will
+     * be the error the promise rejected with.
+     *
+     */
+    reason: E;
+}
+/**
+ * The state of a promise. This is the type that is returned
+ * from `getPromiseState`.
+ *
+ * See also:
+ * - {@link PendingPromise}
+ * - {@link ResolvedPromise}
+ * - {@link RejectedPromise}
+ *
+ */
+export type PromiseState<T = unknown, E = unknown> = PendingPromise | ResolvedPromise<T> | RejectedPromise<E>;
+export declare function createPromiseState<T, E>(promise: Promise<T> | Awaitable<T, E>): Readonly<PromiseState<T, E>>;
+/**
+ * Returns a reactive state-machine for the provided promise or awaitable.
+ *
+ * Repeat calls to `getPromiseState` with the same promise will return the same state object
+ * making is safe and easy to use in templates and JavaScript code to produce reactive
+ * behaviors around promises.
+ *
+ * `getPromiseState` can be used in both JavaScript and Template contexts.
+ *
+ * ```ts
+ * import { getPromiseState } from '@warp-drive/ember';
+ *
+ * const state = getPromiseState(promise);
+ * ```
+ *
+ * For instance, we could write a getter on a component that updates whenever
+ * the promise state advances or the promise changes, by combining the function
+ * with the use of `@cached`
+ *
+ * ```ts
+ * class Component {
+ *   @cached
+ *   get title() {
+ *     const state = getPromiseState(this.args.request);
+ *     if (state.isPending) {
+ *       return 'loading...';
+ *     }
+ *     if (state.isError) { return null; }
+ *     return state.result.title;
+ *   }
+ * }
+ * ```
+ *
+ * Or in a template as a helper:
+ *
+ * ```gjs
+ * import { getPromiseState } from '@warp-drive/ember';
+ *
+ * <template>
+ *   {{#let (getPromiseState @request) as |state|}}
+ *     {{#if state.isPending}} <Spinner />
+ *     {{else if state.isError}} <ErrorForm @error={{state.error}} />
+ *     {{else}}
+ *       <h1>{{state.result.title}}</h1>
+ *     {{/if}}
+ *   {{/let}}
+ * </template>
+ * ```
+ *
+ * If looking to use in a template, consider also the `<Await />` component.
+ *
+ */
+export declare function getPromiseState<T = unknown, E = unknown>(promise: Promise<T> | Awaitable<T, E>): Readonly<PromiseState<T, E>>;
+//# sourceMappingURL=promise-state.d.ts.map

package/declarations/store/-private/new-core-tmp/promise-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"promise-state.d.ts","sourceRoot":"","sources":["../../../../src/store/-private/new-core-tmp/promise-state.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAMrD;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC7B;;;OAGG;IACH,MAAM,EAAE,SAAS,CAAC;IAElB;;;OAGG;IACH,SAAS,EAAE,IAAI,CAAC;IAEhB;;;;OAIG;IACH,SAAS,EAAE,IAAI,CAAC;IAEhB;;;;OAIG;IACH,SAAS,EAAE,KAAK,CAAC;IAEjB;;;;OAIG;IACH,OAAO,EAAE,KAAK,CAAC;IAEf;;;;OAIG;IACH,KAAK,EAAE,IAAI,CAAC;IACZ;;;;;OAKG;IACH,MAAM,EAAE,IAAI,CAAC;IAEb;;;;;;OAMG;IACH,KAAK,EAAE,IAAI,CAAC;IAEZ;;;;OAIG;IACH,MAAM,EAAE,IAAI,CAAC;CACd;AAED;;;;;GAKG;AACH,MAAM,WAAW,eAAe,CAAC,CAAC;IAChC;;;OAGG;IACH,MAAM,EAAE,WAAW,CAAC;IAEpB;;;OAGG;IACH,SAAS,EAAE,KAAK,CAAC;IAEjB;;;;OAIG;IACH,SAAS,EAAE,KAAK,CAAC;IACjB;;;;OAIG;IACH,SAAS,EAAE,IAAI,CAAC;IAEhB;;;;OAIG;IACH,OAAO,EAAE,KAAK,CAAC;IAEf;;;;OAIG;IACH,KAAK,EAAE,CAAC,CAAC;IAET;;;;;OAKG;IACH,MAAM,EAAE,CAAC,CAAC;IAEV;;;;;;OAMG;IACH,KAAK,EAAE,IAAI,CAAC;IAEZ;;;;OAIG;IACH,MAAM,EAAE,IAAI,CAAC;CACd;AAED;;;;;GAKG;AACH,MAAM,WAAW,eAAe,CAAC,CAAC;IAChC;;;OAGG;IACH,MAAM,EAAE,UAAU,CAAC;IAEnB;;;OAGG;IACH,SAAS,EAAE,KAAK,CAAC;IAEjB;;;;OAIG;IACH,SAAS,EAAE,KAAK,CAAC;IAEjB;;;;OAIG;IACH,SAAS,EAAE,KAAK,CAAC;IAEjB;;;;OAIG;IACH,OAAO,EAAE,IAAI,CAAC;IAEd;;;;OAIG;IACH,KAAK,EAAE,IAAI,CAAC;IAEZ;;;;;OAKG;IACH,MAAM,EAAE,IAAI,CAAC;IAEb;;;;;;OAMG;IACH,KAAK,EAAE,CAAC,CAAC;IAET;;;;OAIG;IACH,MAAM,EAAE,CAAC,CAAC;CACX;AAED;;;;;;;;;GASG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,GAAG,OAAO,EAAE,CAAC,GAAG,OAAO,IAAI,cAAc,GAAG,eAAe,CAAC,CAAC,CAAC,GAAG,eAAe,CAAC,CAAC,CAAC,CAAC;AAgB9G,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,QAAQ,CAAC,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CA4C5G;AAaD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,wBAAgB,eAAe,CAAC,CAAC,GAAG,OAAO,EAAE,CAAC,GAAG,OAAO,EACtD,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,GACpC,QAAQ,CAAC,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAU9B"}

package/declarations/store/-private/new-core-tmp/reactivity/configure.d.ts

@@ -0,0 +1,93 @@
+export declare const ARRAY_SIGNAL: "___(unique) Symbol(#[])";
+export declare const OBJECT_SIGNAL: "___(unique) Symbol(#{})";
+/**
+ * Requirements:
+ *
+ * Signal:
+ *
+ * - signal: a way of creating a reference that we can dirty when we desire to notify
+ *         - @signal: a way of creating an accessor on an object that subscribes to a signal on access
+ *                    and notifies the signal on set, or of upgrading a descriptor to be such an accessor
+ *         - defineSignal: a way of creating a signal on an object
+ *         - notifySignal: a way of notifying the underlying signal that it has been dirtied
+ *         - peekSignal: a way of inspecting the signal without notifying it
+ *
+ *  - gate: a memoized getter function that re-runs when on access if its signal is dirty
+ *          conceptually, a gate is a tightly coupled signal and memo
+ *         - @gate: a way of creating a gate on an object or upgrading a descriptor with a getter
+ *                  to be a gate
+ *         - defineGate: a way of creating a gate on an object
+ *         - notifySignal: a way of notifying the signal for a gate that it has been dirtied
+ *
+ * - memo:
+ *        - @memo: a way of creating a memoized getter on an object or upgrading a descriptor with a getter
+ *                 to be a memo
+ *        - defineMemo: a way of creating a memo on an object
+ *
+ * - signalStore: storage bucket for signals associated to an object
+ *        - withSignalStore: a way of pre-creating a signal store on an object
+ *
+ *
+ * @internal
+ */
+/**
+ * An Opaque type that represents a framework specific or TC39 signal.
+ *
+ * It may be an array of signals or a single signal.
+ *
+ * @internal
+ */
+export type SignalRef = unknown;
+/**
+ * The hooks which MUST be configured in order to use this library,
+ * either for framework specfic signals or TC39 signals.
+ *
+ * Support for multiple frameworks simultaneously can be done via
+ * this abstraction by returning multiple signals from the `createSignal`
+ * method, and consuming the correct one via the correct framework via
+ * the `consumeSignal` and `notifySignal` methods.
+ *
+ */
+export interface SignalHooks<T = SignalRef> {
+    createSignal: (obj: object, key: string | symbol) => T;
+    consumeSignal: (signal: T) => void;
+    notifySignal: (signal: T) => void;
+    createMemo: <F>(obj: object, key: string | symbol, fn: () => F) => () => F;
+    willSyncFlushWatchers: () => boolean;
+    waitFor?: <K>(promise: Promise<K>) => Promise<K>;
+}
+export interface HooksOptions {
+    wellknown: {
+        Array: symbol | string;
+    };
+}
+/**
+ * Configures the signals implementation to use. Supports multiple
+ * implementations simultaneously.
+ *
+ * @public
+ * @param buildConfig - a function that takes options and returns a configuration object
+ */
+export declare function setupSignals<T>(buildConfig: (options: HooksOptions) => SignalHooks<T>): void;
+/**
+ * Internal method for consuming the configured `createSignal` hook
+ *
+ * @internal
+ */
+export declare function createSignal(obj: object, key: string | symbol): SignalRef;
+/**
+ * Internal method for consuming the configured `consumeSignal` hook
+ *
+ * @internal
+ */
+export declare function consumeSignal(signal: SignalRef): void;
+/**
+ * Internal method for consuming the configured `notifySignal` hook
+ *
+ * @internal
+ */
+export declare function notifySignal(signal: SignalRef): void;
+export declare function createMemo<T>(object: object, key: string | symbol, fn: () => T): () => T;
+export declare function willSyncFlushWatchers(): boolean;
+export declare function waitFor<K>(promise: Promise<K>): Promise<K>;
+//# sourceMappingURL=configure.d.ts.map

package/declarations/store/-private/new-core-tmp/reactivity/configure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"configure.d.ts","sourceRoot":"","sources":["../../../../../src/store/-private/new-core-tmp/reactivity/configure.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,YAAY,2BAAuC,CAAC;AACjE,eAAO,MAAM,aAAa,2BAAuC,CAAC;AAElE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH;;;;;;GAMG;AACH,MAAM,MAAM,SAAS,GAAG,OAAO,CAAC;AAChC;;;;;;;;;GASG;AACH,MAAM,WAAW,WAAW,CAAC,CAAC,GAAG,SAAS;IACxC,YAAY,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,KAAK,CAAC,CAAC;IACvD,aAAa,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,IAAI,CAAC;IACnC,YAAY,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,IAAI,CAAC;IAClC,UAAU,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,EAAE,MAAM,CAAC,KAAK,MAAM,CAAC,CAAC;IAC3E,qBAAqB,EAAE,MAAM,OAAO,CAAC;IACrC,OAAO,CAAC,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC;CAClD;AAED,MAAM,WAAW,YAAY;IAC3B,SAAS,EAAE;QACT,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;KACxB,CAAC;CACH;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,OAAO,EAAE,YAAY,KAAK,WAAW,CAAC,CAAC,CAAC,QAWrF;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAIzE;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,SAAS,QAK9C;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,SAAS,QAI7C;AAED,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,MAAM,CAAC,CAIxF;AAED,wBAAgB,qBAAqB,IAAI,OAAO,CAI/C;AAED,wBAAgB,OAAO,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAO1D"}

package/declarations/store/-private/new-core-tmp/reactivity/internal.d.ts

@@ -0,0 +1,170 @@
+import { ARRAY_SIGNAL, OBJECT_SIGNAL, type SignalRef } from './configure.ts';
+export type { SignalRef };
+export { ARRAY_SIGNAL, OBJECT_SIGNAL };
+/**
+ * A WarpDriveSignal is a wrapper around a framework specific or TC39 signal
+ * that enables us to store and manage the signal in a universal way.
+ *
+ * WarpDrive uses signals to manage three separate concepts:
+ *
+ * - as a `storage` for a value local to the object that we want to be reactive
+ *   (see `@local` schema field for an example)
+ * - as a `gate` for a memoized getter that we want to act as a reactive property
+ *   but whose value is computed/pulled from a non-reactive source elsewhere
+ *   and whose latest value is stored in the signal
+ *   (see `field` schema field for an example)
+ * - as a `gate` with a manually managed value updated on pull when `isStale` is true
+ *
+ *
+ * It offers
+ *
+ * - a non-reactive way to access/update the current value
+ * - a non-reactive way to mark the signal as dirtied
+ * - a non-reactive way to store content for why the signal was dirtied
+ * - access to the underlying Signal(s) in-use
+ *
+ * For debugging:
+ * - the "key" or "name" of the signal
+ * - the "object identity" or "context" to which the signal is attached
+ *
+ * @internal
+ */
+export interface WarpDriveSignal {
+    /**
+     * The "key" or "name" of the signal.
+     * This is usually (but not always) the name of a property
+     * on the object to which the signal is attached.
+     *
+     * This is used for debugging purposes.
+     * It is not used for any other purpose.
+     *
+     * @internal
+     */
+    key: string | symbol;
+    /**
+     * The "object identity" or "context" to which the
+     * signal is attached.
+     *
+     * This is used for debugging purposes.
+     * It is not used for any other purpose.
+     *
+     * @internal
+     */
+    context: object;
+    /**
+     * The underlying signal(s) in-use.
+     *
+     * Generally, this is a single signal.
+     *
+     * In some cases multiple signals need to be condensed,
+     * such as to support legacy Ember Array APIs or to
+     * support reactive-objects shared between the code of
+     * multiple frameworks.
+     *
+     * In such cases, this value may be an array.
+     *
+     * e.g. (pseudo-code for Ember):
+     *
+     * setupSignals({
+     *   createSignal: (obj, key, initialValue) => {
+     *     if (isArraySignal(key)) {
+     *       return [
+     *         tagForProperty(obj, key),
+     *         tagForProperty(obj, '[]'),
+     *         tagForProperty(obj, 'length'),
+     *       ];
+     *     }
+     *     return tagForProperty(obj, key);
+     *   },
+     *
+     *   consumeSignal: (signal) => {
+     *     if (Array.isArray(signal)) {
+     *       signal.forEach((s) => consumeTag(s));
+     *     } else {
+     *       consumeTag(signal);
+     *     }
+     *   },
+     *
+     *   dirtySignal: (signal) => {
+     *     if (Array.isArray(signal)) {
+     *       signal.forEach((s) => dirtyTag(s));
+     *     } else {
+     *       dirtyTag(signal);
+     *     }
+     *   },
+     * });
+     *
+     * @internal
+     */
+    signal: SignalRef;
+    /**
+     * The last "value" computed for this signal when
+     * a signal is also used for storage.
+     *
+     * @internal
+     */
+    value: unknown;
+    /**
+     * Whether ths signal is known to have been dirtied.
+     * This is useful *both* when manually managing the
+     * `value` cache and when using the signal as a
+     * "gate"
+     *
+     * @internal
+     */
+    isStale: boolean;
+}
+/**
+ * We attach signals to their context object via
+ * a Map attached to the object via this symbol.
+ *
+ * This allows us to store multiple signals
+ * on the same object with smaller memory
+ * overhead and no WeakMap lookups.
+ *
+ * Performance sensitive objects should
+ * pre-warm their shape by assigning this
+ * during initialization.
+ *
+ * ```ts
+ * initializeSignalStore(obj);
+ * ```
+ *
+ * @internal
+ */
+export declare const Signals: "___(unique) Symbol(Signals)";
+export type SignalStore = Map<string | symbol, WarpDriveSignal>;
+/**
+ * A type util to recast the object as having a signal store.
+ *
+ * @internal
+ */
+export declare function upgradeWithSignals<T extends object>(obj: T): asserts obj is T & {
+    [Signals]: SignalStore;
+};
+/**
+ * A util that will create a signal store on the object
+ * if it does not already exist and returns the associated
+ * signal store.
+ *
+ * @internal
+ */
+export declare function withSignalStore<T extends object>(obj: T): SignalStore;
+/**
+ * A util that will create a signal store on the object
+ * if it does not already exist.
+ *
+ * Useful for pre-warming the shape of an object to ensure
+ * a key-transition to add it is not required later.
+ *
+ * @internal
+ */
+export declare function initializeSignalStore<T extends object>(obj: T): asserts obj is T & {
+    [Signals]: SignalStore;
+};
+export declare function createInternalSignal(signals: SignalStore, obj: object, key: string | symbol, initialValue: unknown): WarpDriveSignal;
+export declare function getOrCreateInternalSignal(signals: SignalStore, obj: object, key: string | symbol, initialValue: unknown): WarpDriveSignal;
+export declare function peekInternalSignal(signals: SignalStore | undefined, key: string | symbol): WarpDriveSignal | undefined;
+export declare function consumeInternalSignal(signal: WarpDriveSignal): void;
+export declare function notifyInternalSignal(signal: WarpDriveSignal | undefined): void;
+//# sourceMappingURL=internal.d.ts.map

package/declarations/store/-private/new-core-tmp/reactivity/internal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal.d.ts","sourceRoot":"","sources":["../../../../../src/store/-private/new-core-tmp/reactivity/internal.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,YAAY,EAA6C,aAAa,EAAE,KAAK,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAExH,YAAY,EAAE,SAAS,EAAE,CAAC;AAC1B,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,CAAC;AACvC;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,WAAW,eAAe;IAC9B;;;;;;;;;OASG;IACH,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC;IAErB;;;;;;;;OAQG;IACH,OAAO,EAAE,MAAM,CAAC;IAEhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4CG;IACH,MAAM,EAAE,SAAS,CAAC;IAElB;;;;;OAKG;IACH,KAAK,EAAE,OAAO,CAAC;IAEf;;;;;;;OAOG;IACH,OAAO,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,OAAO,+BAA+C,CAAC;AACpE,MAAM,MAAM,WAAW,GAAG,GAAG,CAAC,MAAM,GAAG,MAAM,EAAE,eAAe,CAAC,CAAC;AAEhE;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,MAAM,EAAE,GAAG,EAAE,CAAC,GAAG,OAAO,CAAC,GAAG,IAAI,CAAC,GAAG;IAAE,CAAC,OAAO,CAAC,EAAE,WAAW,CAAA;CAAE,CAAG;AAE9G;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,CAAC,SAAS,MAAM,EAAE,GAAG,EAAE,CAAC,eAMvD;AAED;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,SAAS,MAAM,EAAE,GAAG,EAAE,CAAC,GAAG,OAAO,CAAC,GAAG,IAAI,CAAC,GAAG;IAAE,CAAC,OAAO,CAAC,EAAE,WAAW,CAAA;CAAE,CAI7G;AAED,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,WAAW,EACpB,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,GAAG,MAAM,EACpB,YAAY,EAAE,OAAO,GACpB,eAAe,CAYjB;AAED,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,WAAW,EACpB,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,GAAG,MAAM,EACpB,YAAY,EAAE,OAAO,GACpB,eAAe,CAMjB;AAED,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,WAAW,GAAG,SAAS,EAChC,GAAG,EAAE,MAAM,GAAG,MAAM,GACnB,eAAe,GAAG,SAAS,CAE7B;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,eAAe,QAE5D;AAED,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,eAAe,GAAG,SAAS,QAKvE"}

package/declarations/store/-private/new-core-tmp/reactivity/signal.d.ts

@@ -0,0 +1,30 @@
+import type { SignalStore, WarpDriveSignal } from './internal.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.
+ *
+ * @internal
+ */
+export 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.
+ *
+ * @internal
+ */
+export declare function defineSignal<T extends object>(obj: T, key: string, v?: unknown): void;
+/**
+ * Define a non-enumerable signal property.
+ *
+ * @internal
+ */
+export declare function defineNonEnumerableSignal<T extends object>(obj: T, key: string, v?: unknown): void;
+export declare function memoized<T extends object, K extends keyof T & string>(target: T, key: K, descriptor: PropertyDescriptor): PropertyDescriptor;
+export declare function gate<T extends object, K extends keyof T & string>(_target: T, key: K, desc: PropertyDescriptor): PropertyDescriptor;
+export declare function defineGate<T extends object>(obj: T, key: string, desc: PropertyDescriptor): void;
+//# sourceMappingURL=signal.d.ts.map

package/declarations/store/-private/new-core-tmp/reactivity/signal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signal.d.ts","sourceRoot":"","sources":["../../../../../src/store/-private/new-core-tmp/reactivity/signal.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAW,WAAW,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAU3E;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,CAAC,SAAS,MAAM,EAC7C,OAAO,EAAE,WAAW,EACpB,GAAG,EAAE,CAAC,EACN,GAAG,EAAE,MAAM,GAAG,MAAM,EACpB,YAAY,EAAE,OAAO,GACpB,eAAe,CAQjB;AAsBD;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAAC,CAAC,SAAS,MAAM,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,CAAC,CAAC,EAAE,OAAO,QAE9E;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,CAAC,SAAS,MAAM,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,CAAC,CAAC,EAAE,OAAO,QAI3F;AAED,wBAAgB,QAAQ,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,CAAC,GAAG,MAAM,EACnE,MAAM,EAAE,CAAC,EACT,GAAG,EAAE,CAAC,EACN,UAAU,EAAE,kBAAkB,sBAoC/B;AAED,wBAAgB,IAAI,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,CAAC,GAAG,MAAM,EAAE,OAAO,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,kBAAkB,sBAqC9G;AAED,wBAAgB,UAAU,CAAC,CAAC,SAAS,MAAM,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,kBAAkB,QAGzF"}