@mittwald/react-ghostmaker 1.5.0-alpha.1 → 1.5.1

package/dist/esm/index.js

@@ -1,7 +1,7 @@
-export { makeGhost } from "./makeGhost";
-export { registerModelIdentifier } from "./modelIdentifier";
-export { getQueryContext, forwardQueryContext } from "./context";
-export { invalidateGhosts } from "./invalidate";
-export * from "./maybeGhost";
-export { GhostMakerModel, ghostMakerModel } from "./metaData";
-export { getModelId, getModelName } from "./queries";
+export { makeGhost } from "./makeGhost.js";
+export { registerModelIdentifier } from "./modelIdentifier.js";
+export { getQueryContext, forwardQueryContext } from "./context.js";
+export { invalidateGhosts } from "./invalidate.js";
+export * from "./maybeGhost/index.js";
+export { GhostMakerModel, ghostMakerModel } from "./metaData.js";
+export { getModelId, getModelName } from "./queries.js";

package/dist/esm/invalidate.js

@@ -1,10 +1,6 @@
+import { withEachGhost } from "./withEachGhost.js";
 export async function invalidateGhosts(queryClient, queryKey) {
-    for (let i = 1; i <= queryKey.length; i++) {
-        const partialKey = queryKey.slice(0, i);
-        const exact = i < queryKey.length;
-        await queryClient.invalidateQueries({
-            queryKey: partialKey,
-            exact,
-        });
-    }
+    await withEachGhost(queryKey, async (filter) => {
+        await queryClient.invalidateQueries(filter);
+    });
 }

package/dist/esm/makeGhost.js

@@ -1,10 +1,11 @@
 import { createElement } from "react";
-import { isGhostMarker, transformFnProp, } from "./types";
-import { useGhostChain } from "./useGhostChain";
-import { RenderComponent } from "./RenderComponent";
-import { resolveGhostChain } from "./resolveGhostChain";
-import { invalidateGhosts } from "./invalidate";
-import { queries } from "./queries";
+import { isGhostMarker, transformFnProp, } from "./types.js";
+import { useGhostChain } from "./useGhostChain.js";
+import { RenderComponent } from "./RenderComponent.js";
+import { resolveGhostChain } from "./resolveGhostChain.js";
+import { invalidateGhosts } from "./invalidate.js";
+import { queries } from "./queries.js";
+import { resetGhosts } from "./reset.js";
 function buildGhostDeep(target, ghostChain) {
     const proxyTarget = (() => {
         // Dummy function to allow ghosting function calls
@@ -28,6 +29,7 @@ function buildGhostDeep(target, ghostChain) {
             return ghost;
         },
         invalidate: (queryClient) => invalidateGhosts(queryClient, queries.ghostChain(target, ghostChain)),
+        reset: (queryClient) => resetGhosts(queryClient, queries.ghostChain(target, ghostChain)),
     };
     const ghost = new Proxy(proxyTarget, {
         get: ($, prop) => {

package/dist/esm/makeGhost.test-d.js

@@ -1,5 +1,5 @@
 import { expectTypeOf, test } from "vitest";
-import { ProjectGhost } from "./testMocks";
+import { ProjectGhost } from "./testMocks.js";
 test("return type is correct", () => {
     const customerNameGhost = ProjectGhost.ofId("Project A")
         .getDetailed()

package/dist/esm/makeGhost.test.js

@@ -1,12 +1,14 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { cleanup, render } from "@testing-library/react";
 import { describe, expect, test, vitest, beforeEach, afterEach } from "vitest";
-import { CustomerDetailed, CustomerGhost, Project, ProjectDetailed, ProjectGhost, advanceSleepTimer, customerMocks, getCustomerNameGhostIds, projectMocks, } from "./testMocks";
+import { CustomerDetailed, CustomerGhost, Project, ProjectDetailed, ProjectGhost, advanceSleepTimer, customerMocks, getCustomerNameGhostIds, projectMocks, } from "./testMocks.js";
 import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
-import { invalidateGhosts } from "./invalidate";
-import { makeGhost } from "./makeGhost";
+import { invalidateGhosts } from "./invalidate.js";
+import { makeGhost } from "./makeGhost.js";
+import { cleanupTargetHashes } from "./useGhostChain.js";
 beforeEach(() => {
     vitest.useFakeTimers();
+    cleanupTargetHashes();
 });
 afterEach(() => {
     vitest.runOnlyPendingTimers();
@@ -181,7 +183,7 @@ describe("Hooks", () => {
             expect(customerMocks.getDetailed).toHaveBeenCalledTimes(1);
             expect(customerMocks.getName).toHaveBeenCalledTimes(1);
             result.current?.invalidate();
-            await vitest.advanceTimersByTimeAsync(100000);
+            await vitest.runOnlyPendingTimersAsync();
             expect(projectMocks.getDetailed).toHaveBeenCalledTimes(2);
             expect(customerMocks.getDetailed).toHaveBeenCalledTimes(2);
             expect(customerMocks.getName).toHaveBeenCalledTimes(2);
@@ -196,7 +198,7 @@ describe("Hooks", () => {
             expect(customerMocks.getDetailed).toHaveBeenCalledTimes(1);
             expect(customerMocks.getName).toHaveBeenCalledTimes(1);
             ghost.invalidate(queryClient);
-            await vitest.advanceTimersByTimeAsync(10000);
+            await vitest.runOnlyPendingTimersAsync();
             expect(projectMocks.getDetailed).toHaveBeenCalledTimes(2);
             expect(customerMocks.getDetailed).toHaveBeenCalledTimes(2);
             expect(customerMocks.getName).toHaveBeenCalledTimes(2);
@@ -211,7 +213,7 @@ describe("Hooks", () => {
             expect(customerMocks.getDetailed).toHaveBeenCalledTimes(1);
             expect(customerMocks.getName).toHaveBeenCalledTimes(1);
             invalidateGhosts(queryClient, getCustomerNameGhostIds.current.queryKey);
-            await vitest.advanceTimersByTimeAsync(10000);
+            await vitest.runOnlyPendingTimersAsync();
             expect(projectMocks.getDetailed).toHaveBeenCalledTimes(2);
             expect(customerMocks.getDetailed).toHaveBeenCalledTimes(2);
             expect(customerMocks.getName).toHaveBeenCalledTimes(2);
@@ -223,7 +225,7 @@ describe("Hooks", () => {
             expect(projectMocks.getDetailed).toHaveBeenCalledTimes(1);
             expect(customerMocks.getDetailed).toHaveBeenCalledTimes(1);
             ghost.invalidate(queryClient);
-            await vitest.advanceTimersByTimeAsync(10000);
+            await vitest.runOnlyPendingTimersAsync();
             expect(projectMocks.getDetailed).toHaveBeenCalledTimes(2);
             expect(customerMocks.getDetailed).toHaveBeenCalledTimes(2);
         });
@@ -234,7 +236,7 @@ describe("Hooks", () => {
             expect(projectMocks.getDetailed).toHaveBeenCalledTimes(1);
             expect(customerMocks.getDetailed).toHaveBeenCalledTimes(0);
             specialGhost.invalidate(queryClient);
-            await vitest.advanceTimersByTimeAsync(10000);
+            await vitest.runOnlyPendingTimersAsync();
             expect(projectMocks.getDetailed).toHaveBeenCalledTimes(2);
             expect(customerMocks.getDetailed).toHaveBeenCalledTimes(0);
         });
@@ -246,7 +248,7 @@ describe("Hooks", () => {
                 .fn()
                 .mockImplementation((id) => new ProjectDetailed(id, `CHANGED! Project ${id}`, "C1"));
             projectGhost.invalidate(queryClient);
-            await vitest.advanceTimersByTimeAsync(10000);
+            await vitest.runOnlyPendingTimersAsync();
             expect(projectMocks.getName).toHaveBeenCalledTimes(2);
         });
     });

package/dist/esm/maybeGhost/asGhost.js

@@ -1,5 +1,5 @@
-import { makeGhost } from "../makeGhost";
-import { isReactGhost } from "../types";
+import { makeGhost } from "../makeGhost.js";
+import { isReactGhost } from "../types.js";
 export function asGhost(maybeGhost) {
     if (isReactGhost(maybeGhost)) {
         return maybeGhost;

package/dist/esm/maybeGhost/asGhost.test.js

@@ -1,5 +1,5 @@
-import { asGhostProps } from "../maybeGhost";
-import { isReactGhost } from "../types";
+import { asGhostProps } from "../maybeGhost/index.js";
+import { isReactGhost } from "../types.js";
 import { expect, test } from "vitest";
 test("makes Ghosts of all props", () => {
     const ghostProps = asGhostProps({

package/dist/esm/maybeGhost/index.js

@@ -1,2 +1,2 @@
-export * from "./asGhost";
-export * from "./types";
+export * from "./asGhost.js";
+export * from "./types.js";

package/dist/esm/maybeGhost/types.test-d.js

@@ -1,5 +1,5 @@
 import { describe, expectTypeOf, test } from "vitest";
-import { asGhostProps } from "./asGhost";
+import { asGhostProps } from "./asGhost.js";
 describe("fixupMaybeReactGhostProps()", () => {
     test("works for one prop", () => {
         expectTypeOf(asGhostProps({})).toEqualTypeOf();

package/dist/esm/polytype.js

@@ -1,4 +1,4 @@
 import { getPrototypeListOf } from "polytype";
-import { getProtoypes } from "./metaData";
+import { getProtoypes } from "./metaData.js";
 getProtoypes.current = getPrototypeListOf;
-export { GhostMakerModel } from "./metaData";
+export { GhostMakerModel } from "./metaData.js";

package/dist/esm/queries.js

@@ -1,7 +1,7 @@
 import is from "@sindresorhus/is";
-import { hashObject } from "./hash";
-import { getMetaData } from "./metaData";
-import { modelIdentifiers } from "./modelIdentifier";
+import { hashObject } from "./hash.js";
+import { getMetaData } from "./metaData.js";
+import { modelIdentifiers } from "./modelIdentifier.js";
 export const getModelName = (something) => {
     return getMetaData(something)?.name;
 };

package/dist/esm/queries.test.js

@@ -32,7 +32,7 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
     }
     return useValue ? value : void 0;
 };
-import { getMetaData, GhostMakerModel } from "./metaData";
+import { getMetaData, GhostMakerModel } from "./metaData.js";
 import { expect, test } from "vitest";
 let GrandParent = (() => {
     let _classDecorators = [GhostMakerModel({

package/dist/esm/reset.js

@@ -0,0 +1,6 @@
+import { withEachGhost } from "./withEachGhost.js";
+export async function resetGhosts(queryClient, queryKey) {
+    await withEachGhost(queryKey, async (filter) => {
+        await queryClient.resetQueries(filter);
+    });
+}

package/dist/esm/resolveGhostChain.js

@@ -1,6 +1,5 @@
 import is, { assert } from "@sindresorhus/is";
-import { isReactGhost, transformFnProp, } from "./types";
-import { getQueryContext, ghostFnContext } from "./context";
+import { isReactGhost, transformFnProp, } from "./types.js";
 const resolveGhostChainItem = async (target, item) => {
     const { propName, args } = item;
     if (propName === transformFnProp) {
@@ -22,19 +21,13 @@ const resolveGhostChainItem = async (target, item) => {
         return property;
     }
     assert.function(property);
-    return property.call(target, ...args);
+    const asyncFn = property.bind(target);
+    return await asyncFn(...args);
 };
 export const resolveGhostChain = async (target, stack) => {
     let result = target;
-    const queryContext = getQueryContext();
     for (const item of stack) {
-        if (queryContext) {
-            const resolveGhostChainItemWithContext = ghostFnContext.bind({ query: queryContext }, resolveGhostChainItem);
-            result = await resolveGhostChainItemWithContext(result, item);
-        }
-        else {
-            result = await resolveGhostChainItem(result, item);
-        }
+        result = await resolveGhostChainItem(result, item);
     }
     return result;
 };

package/dist/esm/testMocks.js

@@ -33,8 +33,8 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
     return useValue ? value : void 0;
 };
 import { beforeEach, vitest } from "vitest";
-import { getQueryContext, makeGhost } from ".";
-import { GhostMakerModel } from "./metaData";
+import { getQueryContext, makeGhost } from "./index.js";
+import { GhostMakerModel } from "./metaData.js";
 const sleep = () => new Promise((resolve) => setTimeout(resolve, 200));
 export const advanceSleepTimer = async (times = 1) => {
     for (let i = 0; i < times; i++) {

package/dist/esm/useGhostChain.js

@@ -1,52 +1,84 @@
-import is from "@sindresorhus/is";
-import { useEffect, useEffectEvent, useRef } from "react";
+import is, { assert } from "@sindresorhus/is";
+import { useEffect, useEffectEvent, useMemo } from "react";
+import { transformFnProp, } from "./types.js";
 import { useQueryClient, useSuspenseQuery } from "@tanstack/react-query";
-import { queries } from "./queries";
-import { ghostFnContext } from "./context";
-import { hashObject } from "./hash";
-import { resolveGhostChain } from "./resolveGhostChain";
+import { queries } from "./queries.js";
+import { ghostFnContext } from "./context.js";
+import { invalidateGhosts } from "./invalidate.js";
+import { hashObject } from "./hash.js";
+import { resetGhosts } from "./reset.js";
 export const useGhostChain = (target, chain, options) => {
     const queryClient = useQueryClient();
-    const queryKey = queries.ghostChain(target, chain);
-    const fn = () => resolveGhostChain(target, chain);
-    const queryResult = useSuspenseQuery({
+    const context = {
+        queryKey: queries.target(target),
+    };
+    const value = chain.reduce((currentTarget, item) => useGhostChainItem(currentTarget, item, options, context), target);
+    const invalidate = () => invalidateGhosts(queryClient, queries.ghostChain(target, chain));
+    const reset = () => resetGhosts(queryClient, queries.ghostChain(target, chain));
+    return {
+        value,
+        invalidate,
+        reset,
+    };
+};
+const useGhostChainItem = (target, item, options = {}, context) => {
+    const { propName, args } = item;
+    if (propName === transformFnProp) {
+        assert.array(args);
+        const transformFn = args[0];
+        assert.function(transformFn, "transform requires a mapping function");
+        const transformDependencies = args[1] ?? [];
+        assert.array(transformDependencies);
+        return useMemo(() => transformFn(target), [target, ...transformDependencies]);
+    }
+    if (is.nullOrUndefined(target)) {
+        return target;
+    }
+    assert.object(target);
+    const targetPropertyName = propName;
+    const targetProperty = target[targetPropertyName];
+    context.queryKey = queries.chainItem(context.queryKey, item);
+    if (args === undefined) {
+        // no function call, just a property access
+        return targetProperty;
+    }
+    assert.function(targetProperty);
+    const targetFn = targetProperty.bind(target);
+    const queryKey = [...context.queryKey];
+    const query = useSuspenseQuery({
         ...options,
+        queryKey,
         queryFn: async (ctx) => {
-            const targetFnWithContext = ghostFnContext.bind({ query: ctx }, fn);
-            return { result: await targetFnWithContext() };
+            const targetFnWithContext = ghostFnContext.bind({ query: ctx }, targetFn);
+            return { result: await targetFnWithContext(...args) };
         },
-        queryKey,
     });
-    if (queryResult.error) {
-        throw queryResult.error;
-    }
     useTargetAutoInvalidate(target, queryKey);
-    return {
-        value: queryResult.data.result,
-        invalidate: () => queryClient.invalidateQueries({
-            queryKey,
-        }),
-    };
+    if (query.error) {
+        throw query.error;
+    }
+    return query.data.result;
 };
+const targetHashes = new Map();
 const useTargetAutoInvalidate = (target, queryKey) => {
     const queryClient = useQueryClient();
-    const invalidate = () => queryClient.invalidateQueries({
-        queryKey,
-    });
-    const targetHash = is.object(target) ? hashObject(target) : target;
-    const prevTargetHash = useRef(targetHash);
-    const joinedQueryKey = queryKey.join(".");
-    const prevQueryId = useRef(joinedQueryKey);
-    const needsRefresh = prevQueryId.current === joinedQueryKey &&
-        prevTargetHash.current !== targetHash;
-    prevTargetHash.current = targetHash;
-    prevQueryId.current = joinedQueryKey;
     const onTargetChangeEvent = useEffectEvent(() => {
+        const joinedQueryKey = queryKey.join(".");
+        const targetHash = hashObject(target);
+        const prevTargetHash = targetHashes.get(joinedQueryKey);
+        const needsRefresh = prevTargetHash !== undefined && prevTargetHash !== targetHash;
+        targetHashes.set(joinedQueryKey, targetHash);
         if (needsRefresh) {
-            invalidate();
+            queryClient.invalidateQueries({
+                queryKey,
+            });
         }
     });
     useEffect(() => {
         onTargetChangeEvent();
-    }, [needsRefresh]);
+    }, [target]);
+};
+/** @internal */
+export const cleanupTargetHashes = () => {
+    targetHashes.clear();
 };

package/dist/esm/withEachGhost.js

@@ -0,0 +1,10 @@
+export const withEachGhost = async (queryKey, callback) => {
+    for (let i = 1; i <= queryKey.length; i++) {
+        const partialKey = queryKey.slice(0, i);
+        const exact = i < queryKey.length;
+        await callback({
+            queryKey: partialKey,
+            exact,
+        });
+    }
+};

package/dist/types/index.d.ts

@@ -1,8 +1,8 @@
-export { makeGhost } from "./makeGhost";
-export { registerModelIdentifier } from "./modelIdentifier";
-export { type ReactGhost, UseGhostReturn } from "./types";
-export { getQueryContext, forwardQueryContext } from "./context";
-export { invalidateGhosts } from "./invalidate";
-export * from "./maybeGhost";
-export { GhostMakerModel, ghostMakerModel } from "./metaData";
-export { getModelId, getModelName } from "./queries";
+export { makeGhost } from "./makeGhost.ts";
+export { registerModelIdentifier } from "./modelIdentifier.ts";
+export { type ReactGhost, UseGhostReturn } from "./types.ts";
+export { getQueryContext, forwardQueryContext } from "./context.ts";
+export { invalidateGhosts } from "./invalidate.ts";
+export * from "./maybeGhost/index.ts";
+export { GhostMakerModel, ghostMakerModel } from "./metaData.ts";
+export { getModelId, getModelName } from "./queries.ts";

package/dist/types/invalidate.d.ts

@@ -1,3 +1,3 @@
 import { type QueryClient } from "@tanstack/react-query";
-import type { QueryKey } from "./types";
+import type { QueryKey } from "./types.ts";
 export declare function invalidateGhosts(queryClient: QueryClient, queryKey: QueryKey): Promise<void>;

package/dist/types/makeGhost.d.ts

@@ -1,2 +1,2 @@
-import { type ReactGhost } from "./types";
+import { type ReactGhost } from "./types.ts";
 export declare function makeGhost<T>(target: T): ReactGhost<T>;

package/dist/types/maybeGhost/asGhost.d.ts

@@ -1,4 +1,4 @@
-import { type ReactGhost } from "../types";
-import type { MaybeReactGhost, PropsWithFixedUpReactGhosts, PropsWithMaybeReactGhosts } from "./types";
+import { type ReactGhost } from "../types.ts";
+import type { MaybeReactGhost, PropsWithFixedUpReactGhosts, PropsWithMaybeReactGhosts } from "./types.ts";
 export declare function asGhost<T>(maybeGhost: MaybeReactGhost<T>): ReactGhost<T>;
 export declare function asGhostProps<T, TProps extends (keyof T)[] = (keyof T)[]>(props: PropsWithMaybeReactGhosts<T, TProps>, keys?: TProps): PropsWithFixedUpReactGhosts<T, TProps>;

package/dist/types/maybeGhost/index.d.ts

@@ -1,2 +1,2 @@
-export * from "./asGhost";
-export * from "./types";
+export * from "./asGhost.ts";
+export * from "./types.ts";

package/dist/types/maybeGhost/types.d.ts

@@ -1,4 +1,4 @@
-import { type OrOptional, type ReactGhost } from "../types";
+import { type OrOptional, type ReactGhost } from "../types.ts";
 export type MaybeReactGhost<T> = T extends ReactGhost<infer U> ? ReactGhost<U> | U : T | ReactGhost<T>;
 export type PropsWithMaybeReactGhosts<T, TProps extends (keyof T)[]> = {
     [K in keyof T]: K extends TProps[number] ? MaybeReactGhost<T[K] | OrOptional<T[K]>> : T[K] | OrOptional<T[K]>;

package/dist/types/modelIdentifier.d.ts

@@ -1,4 +1,4 @@
-import type { ModelIdentifier } from "./types";
+import type { ModelIdentifier } from "./types.ts";
 export declare const modelIdentifiers: ModelIdentifier[];
 /** @deprecated Use GhostMakerModel (decorator) instead */
 export declare const registerModelIdentifier: (identifier: ModelIdentifier) => void;

package/dist/types/polytype.d.ts

@@ -1 +1 @@
-export { GhostMakerModel } from "./metaData";
+export { GhostMakerModel } from "./metaData.ts";

package/dist/types/queries.d.ts

@@ -1,9 +1,9 @@
-import type { GhostChain, GhostChainItem, QueryKey } from "./types";
+import type { GhostChain, GhostChainItem, QueryKey } from "./types.ts";
 export declare const getModelName: (something: unknown) => string | undefined;
 export declare const getModelId: (something: unknown) => string | undefined;
 export declare const queries: {
     ghostmaker: () => string[];
     target: (target: unknown) => string[];
-    chainItem: (prev: QueryKey, chainItem: GhostChainItem) => QueryKey;
-    ghostChain: (target: unknown, chain: GhostChain) => QueryKey;
+    chainItem: (prev: QueryKey, chainItem: GhostChainItem) => unknown[];
+    ghostChain: (target: unknown, chain: GhostChain) => unknown[];
 };

package/dist/types/reset.d.ts

@@ -0,0 +1,3 @@
+import { type QueryClient } from "@tanstack/react-query";
+import type { QueryKey } from "./types.ts";
+export declare function resetGhosts(queryClient: QueryClient, queryKey: QueryKey): Promise<void>;

package/dist/types/resolveGhostChain.d.ts

@@ -1,2 +1,2 @@
-import { type GhostChain } from "./types";
+import { type GhostChain } from "./types.ts";
 export declare const resolveGhostChain: (target: unknown, stack: GhostChain) => Promise<unknown>;

package/dist/types/testMocks.d.ts

@@ -41,5 +41,5 @@ export declare class ProjectDetailed {
     getName(): string;
     getStatus(): Promise<string>;
 }
-export declare const ProjectGhost: import("./types").ReactGhost<typeof Project>;
-export declare const CustomerGhost: import("./types").ReactGhost<typeof Customer>;
+export declare const ProjectGhost: import("./types.ts").ReactGhost<typeof Project>;
+export declare const CustomerGhost: import("./types.ts").ReactGhost<typeof Customer>;

package/dist/types/types.d.ts

@@ -7,13 +7,16 @@ export type AnyFunction = (...args: ExplicitAny[]) => ExplicitAny;
 export interface UseQueryReturnType<T> {
     result: T;
 }
-export type useGhostOptions<T = unknown> = Omit<UseQueryOptions<UseQueryReturnType<T>>, "queryKey" | "queryFn">;
+export type UseGhostOptions<T = unknown> = Omit<UseQueryOptions<UseQueryReturnType<T>>, "queryKey" | "queryFn">;
+/** @deprecated Use `UseGhostOptions<unknown>` instead. */
+export type useGhostOptions = UseGhostOptions<unknown>;
 export interface ReactGhostMethods<T> extends Promise<T> {
-    useGhost: (options?: useGhostOptions) => UseGhostReturn<T>;
-    use: (options?: useGhostOptions) => T;
+    useGhost: (options?: UseGhostOptions<T>) => UseGhostReturn<T>;
+    use: (options?: UseGhostOptions<T>) => T;
     render: (transform?: (item: T) => ReactNode) => ReactNode;
     transform: <U, U2 = U>(fn: (item: T extends ReactGhost<infer T2> ? T2 : T) => U2, dependencies?: DependencyList) => ReactGhost<U2>;
     invalidate: (queryClient: QueryClient) => Promise<void>;
+    reset: (queryClient: QueryClient) => Promise<void>;
 }
 export declare const transformFnProp: "___transformFn";
 export declare const isGhostMarker: "___ghostMarker";
@@ -28,12 +31,14 @@ export type GhostChain = GhostChainItem[];
 export type GhostChainTargetType = UnknownRecord | Class<unknown> | null | undefined;
 export type QueryKey = readonly unknown[];
 export type InvalidateGhostFn = () => Promise<void>;
+export type ResetGhostFn = () => Promise<void>;
 export interface GhostChainContext {
     queryKey: QueryKey;
 }
 export interface UseGhostReturn<T> {
     value: T;
     invalidate: InvalidateGhostFn;
+    reset: ResetGhostFn;
 }
 export declare function isReactGhost<T>(something: unknown): something is ReactGhost<T>;
 export type ModelIdentifier = (model: unknown) => string | undefined;

package/dist/types/useGhostChain.d.ts

@@ -1,2 +1,2 @@
-import { type GhostChain, type useGhostOptions, type UseGhostReturn } from "./types";
-export declare const useGhostChain: <T>(target: unknown, chain: GhostChain, options?: useGhostOptions) => UseGhostReturn<T>;
+import { type GhostChain, type UseGhostOptions, type UseGhostReturn } from "./types.ts";
+export declare const useGhostChain: <T>(target: unknown, chain: GhostChain, options?: UseGhostOptions<T>) => UseGhostReturn<T>;

package/dist/types/withEachGhost.d.ts

@@ -0,0 +1,2 @@
+import type { QueryFilters, QueryKey } from "@tanstack/react-query";
+export declare const withEachGhost: (queryKey: QueryKey, callback: (queryFilters: QueryFilters) => Promise<void>) => Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mittwald/react-ghostmaker",
-  "version": "1.5.0-alpha.1",
+  "version": "1.5.1",
   "author": "Mittwald CM Service GmbH & Co. KG <opensource@mittwald.de>",
   "contributors": [
     "Marco Falkenberg <m.falkenberg@mittwald.de>"
@@ -38,38 +38,38 @@
     "dist"
   ],
   "dependencies": {
-    "@sindresorhus/is": "^7.1.0",
+    "@sindresorhus/is": "^7.2.0",
     "context": "^3.0.33",
-    "object-code": "^1.3.4",
-    "type-fest": "^5.1.0"
+    "object-code": "^2.0.0",
+    "type-fest": "^5.4.4"
   },
   "devDependencies": {
-    "@eslint/eslintrc": "^3.3.1",
-    "@eslint/js": "^9.39.1",
-    "@tanstack/react-query": "^5.90.5",
+    "@eslint/eslintrc": "^3.3.3",
+    "@eslint/js": "^9.39.2",
+    "@tanstack/react-query": "^5.90.20",
     "@testing-library/dom": "^10.4.1",
-    "@testing-library/react": "^16.3.0",
-    "@types/react": "^19.2.2",
-    "@types/react-dom": "^19.2.2",
-    "@typescript-eslint/eslint-plugin": "^8.46.3",
-    "@typescript-eslint/parser": "^8.46.1",
-    "eslint": "^9.37.0",
+    "@testing-library/react": "^16.3.2",
+    "@types/react": "^19.2.13",
+    "@types/react-dom": "^19.2.3",
+    "@typescript-eslint/eslint-plugin": "^8.54.0",
+    "@typescript-eslint/parser": "^8.54.0",
+    "eslint": "^9.39.2",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-json": "^4.0.1",
-    "eslint-plugin-prettier": "^5.5.4",
+    "eslint-plugin-prettier": "^5.5.5",
     "globals": "^16.5.0",
-    "happy-dom": "^20.0.2",
+    "happy-dom": "^20.5.3",
     "license-checker-rseidelsohn": "^4.4.2",
     "polytype": "^0.17.0",
-    "prettier": "^3.6.2",
-    "prettier-plugin-jsdoc": "^1.3.3",
-    "prettier-plugin-pkgsort": "^0.2.1",
-    "prettier-plugin-sort-json": "^4.1.1",
-    "react": "^19.2.0",
-    "react-dom": "^19.2.0",
-    "rimraf": "^6.0.1",
+    "prettier": "^3.8.1",
+    "prettier-plugin-jsdoc": "^1.8.0",
+    "prettier-plugin-pkgsort": "^0.3.0",
+    "prettier-plugin-sort-json": "^4.2.0",
+    "react": "^19.2.4",
+    "react-dom": "^19.2.4",
+    "rimraf": "^6.1.2",
     "typescript": "^5.9.3",
-    "vitest": "^3.2.4"
+    "vitest": "^4.0.18"
   },
   "peerDependencies": {
     "@tanstack/react-query": "^5",